SymPy - 快速指南

---

SymPy - 简介

SymPy 是一个用于执行符号计算的 Python 库。它是一个计算机代数系统(CAS)，既可以用作独立应用程序，也可以用作其他应用程序的库。其现场会议也可在https://live.sympy.org/上观看。由于它是一个纯Python库，因此它可以用作交互模式和编程应用程序。SymPy 现在已成为科学 Python 生态系统中流行的符号库。

SymPy 具有广泛的功能，适用于基本符号算术、微积分、代数、离散数学、量子物理等领域。SymPy 能够将结果格式化为多种格式，包括 LaTeX、MathML 等。SymPy 分布在新的 BSD 许可证。由Ondřej Čertík和Aaron Meurer领导的开发团队于 2007 年发布了 SymPy 的第一个版本。当前版本是 1.5.1。

SymPy 的一些应用领域是 -

• 多项式
• 结石
• 离散数学
• 矩阵
• 几何学
• 绘图
• 物理
• 统计数据
• 组合学

SymPy - 安装

SymPy 有一个重要的必备库，名为mpmath。它是一个用于任意精度的实际复杂浮点运算的 Python 库。但是，当安装 SymPy 时，Python 的包安装程序 PIP 会自动安装它，如下所示 -

pip install sympy

其他 Python 发行版，例如 Anaconda、Enthought Canopy 等，可能已经捆绑了 SymPy。要进行验证，您可以在 Python 提示符中键入以下内容 -

>>> import sympy
>>> sympy.__version__

您将得到以下输出作为当前版本的 sympy -

‘1.5.1’

SymPy 包的源代码可在https://github.com/sympy/sympy获取。

SymPy - 符号计算

符号计算是指用于操作数学表达式和其他数学对象的算法的开发。符号计算将数学与计算机科学相结合，利用数学符号来求解数学表达式。计算机代数系统 (CAS)（例如 SymPy）使用传统手动方法中使用的相同符号精确（而不是近似）计算代数表达式。例如，我们使用 Python 的数学模块计算数字的平方根，如下所示 -

>>> import math 
>>> print (math.sqrt(25), math.sqrt(7))

上述代码片段的输出如下 -

5.0 2.6457513110645907

正如您所看到的，7 的平方根是近似计算的。但在 SymPy 中，非完美平方数的平方根默认不计算，如下所示 -

>>> import sympy 
>>> print (sympy.sqrt(7))

上述代码片段的输出如下 -

开方(7)

可以使用下面的代码片段以符号方式简化和显示表达式结果 -

>>> import math
>>> print (math.sqrt(12))

上述代码片段的输出如下 -

3.4641016151377544

您需要使用下面的代码片段来使用 sympy 执行相同的操作 -

##sympy output 
>>> print (sympy.sqrt(12))

其输出如下 -

2*平方(3)

SymPy 代码在 Jupyter Notebook 中运行时，利用 MathJax 库以 LatEx 形式呈现数学符号。它如下面的代码片段所示 -

>>> from sympy import * 
>>> x=Symbol ('x') 
>>> expr = integrate(x**x, x) 
>>> expr

在 python shell 中执行上述命令时，将生成以下输出 -

Integral(x**x, x)

这相当于

$\int \mathrm{x}^{x}\,\mathrm{d}x$

非完美平方的平方根可以用 Latex 使用传统符号表示如下 -

>>> from sympy import * 
>>> x=7 
>>> sqrt(x)

上述代码片段的输出如下 -

$\sqrt7$

SymPy 等符号计算系统以符号方式进行各种计算（例如导数、积分和极限、求解方程、处理矩阵）。SymPy 包有不同的模块，支持绘图、打印（如 LATEX）、物理、统计、组合、数论、几何、逻辑等。

SymPy - 数字

SymPy 包中的核心模块包含表示Atomics序数的 Number 类。该类有两个子类：Float 类和 Rational 类。Rational 类由 Integer 类进一步扩展。

Float 类表示任意精度的浮点数。

>>> from sympy import Float 
>>> Float(6.32)

上述代码片段的输出如下 -

6.32

SymPy 可以将整数或字符串转换为浮点数。

>>> Float(10)

10.0

Float('1.33E5')# scientific notation

133000.0

转换为浮点数时，还可以指定精度位数，如下所示 -

>>> Float(1.33333,2)

上述代码片段的输出如下 -

1.3

数字 (p/q) 的表示被表示为 Rational 类的对象，其中 q 是非零数字。

>>> Rational(3/4)

上述代码片段的输出如下 -

$\frac{3}{4}$

如果将浮点数传递给 Rational() 构造函数，它将返回其二进制表示形式的基础值

>>> Rational(0.2)

上述代码片段的输出如下 -

$\frac{3602879701896397}{18014398509481984}$

为了更简单的表示，请指定分母限制。

>>> Rational(0.2).limit_denominator(100)

上述代码片段的输出如下 -

$\frac{1}{5}$

当将字符串传递给 Rational() 构造函数时，将返回任意精度的有理数。

>>> Rational("3.65")

上述代码片段的输出如下 -

$\frac{73}{20}$

如果传递两个数字参数，也可以获得 Rational 对象。分子和分母部分可作为属性使用。

>>> a=Rational(3,5) 
>>> print (a) 
>>> print ("numerator:{}, denominator:{}".format(a.p, a.q))

上述代码片段的输出如下 -

3/5

分子：3，分母：5

>>> a

上述代码片段的输出如下 -

$\frac{3}{5}$

SymPy 中的整数类表示任意大小的整数。构造函数可以接受浮点数或有理数，但小数部分被丢弃

>>> Integer(10)

上述代码片段的输出如下 -

10

>>> Integer(3.4)

上述代码片段的输出如下 -

3

>>> Integer(2/7)

上述代码片段的输出如下 -

0

SymPy 有一个RealNumber类，充当 Float 的别名。SymPy 还将 Zero 和 One 定义为可分别通过 S.Zero 和 S.One 访问的单例类，如下所示 -

>>> S.Zero

输出如下 -

0

>>> S.One

输出如下 -

1

其他预定义的 Singleton 数字对象有 Half、NaN、Infinity 和 ImaginaryUnit

>>> from sympy import S 
>>> print (S.Half)

输出如下 -

½

>>> print (S.NaN)

输出如下 -

南

Infinity 可用作 oo 符号对象或 S.Infinity

>>> from sympy import oo 
>>> oo

上述代码片段的输出如下 -

$\infty$

>>> S.Infinity

上述代码片段的输出如下 -

$\infty$

ImaginaryUnit 数字可以作为 I 符号导入或作为 S.ImaginaryUnit 访问，表示 -1 的平方根

>>> from sympy import I 
>>> I

当您执行上面的代码片段时，您会得到以下输出 -

我

>>> S.ImaginaryUnit

上述代码片段的输出如下 -

我

>>> from sympy import sqrt 
>>> i=sqrt(-1) 
>>> i*i

当您执行上面的代码片段时，您会得到以下输出 -

-1

SymPy - 符号

Symbol是 symPy 库中最重要的类。正如前面提到的，符号计算是用符号完成的。SymPy 变量是 Symbols 类的对象。

Symbol() 函数的参数是一个包含可以分配给变量的符号的字符串。

>>> from sympy import Symbol 
>>> x=Symbol('x') 
>>> y=Symbol('y') 
>>> expr=x**2+y**2 
>>> expr

上面的代码片段给出了相当于下面表达式的输出 -

$x^2 + y^2$

一个符号可以由多个字母组成。

>>> s=Symbol('side') 
>>> s**3

上面的代码片段给出了相当于下面表达式的输出 -

$边^3$

SymPy 还有一个Symbols()函数，可以一次定义多个符号。字符串包含由逗号或空格分隔的变量名称。

>>> from sympy import symbols 
>>> x,y,z=symbols("x,y,z")

在 SymPy 的 abc 模块中，所有拉丁字母和希腊字母都被定义为符号。因此，这种方法比实例化Symbol对象更方便。

>>> from sympy.abc import x,y,z

然而，名称C、O、S、I、N、E和Q是预定义的符号。另外，abc 模块中没有定义具有多个字母的符号，为此您应该使用上面的 Symbol 对象。abc 模块定义了可以检测默认 SymPy 命名空间中的定义的特殊名称。crash1 包含单个字母，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 是数字，则将左侧的所有连续数字视为非负起始值。右侧所有连续数字均被视为比结束值大 1。

>>> from sympy import symbols 
>>> symbols('a:5')

上述代码片段的输出如下 -

（a0、a1、a2、a3、a4）

>>> symbols('mark(1:4)')

上述代码片段的输出如下 -

（标记1、标记2、标记3）

SymPy - 替换

对数学表达式执行的最基本运算之一是替换。SymPy 中的 subs() 函数将所有出现的第一个参数替换为第二个参数。

>>> from sympy.abc import x,a 
>>> expr=sin(x)*sin(x)+cos(x)*cos(x) 
>>> expr

上面的代码片段给出了相当于下面表达式的输出 -

$\sin^2(x)+\cos^2(x)$

>>> expr.subs(x,a)

上面的代码片段给出了相当于下面表达式的输出 -

$\sin^2(a)+\cos^2(a)$

如果我们想要计算某个表达式，这个函数非常有用。例如，我们想通过将 a 替换为 5 来计算以下表达式的值。

>>> expr=a*a+2*a+5 
>>> expr

上面的代码片段给出了相当于下面表达式的输出 -

$a^2 + 2a + 5$

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

上面的代码片段给出了相当于下面表达式的输出 -

$(2a + b)^2$

SymPy - sympify() 函数

sympify() 函数用于转换任意表达式，使其可以用作 SymPy 表达式。普通 Python 对象（例如整数对象）在 SymPy 中进行转换。整数等、字符串也转换为 SymPy 表达式。

>>> expr="x**2+3*x+2" 
>>> expr1=sympify(expr) 
>>> expr1 
>>> expr1.subs(x,2)

上面的代码片段给出了以下输出 -

12

任何Python对象都可以转换为SymPy对象。但是，由于转换内部使用 eval() 函数，因此不应使用未经净化的表达式，否则会引发 SympifyError。

>>> sympify("x***2")
---------------------------------------------------------------------------

SympifyError：表达式“无法解析”x***2”的 Sympify 失败，因为引发了异常。

sympify() 函数采用以下参数： * strict：默认值为 False。如果设置为 True，则仅转换已定义显式转换的类型。否则，将引发 SympifyError。* 评估：如果设置为 False，算术和运算符将转换为其 SymPy 等效项，而不评估表达式。

>>> sympify("10/5+4/2")

上面的代码片段给出了以下输出 -

4

>>> sympify("10/5+4/2", evaluate=False)

上面的代码片段给出了以下输出 -

$\frac{10}{5}+\frac{4}{2}$

SymPy - evalf() 函数

此函数计算给定的数值表达式，最高可达 100 位的给定浮点精度。该函数还采用 subs 参数，一个符号数值的字典对象。考虑以下表达式

>>> from sympy.abc import r 
>>> expr=pi*r**2 
>>> expr

上面的代码片段给出了相当于下面表达式的输出 -

$\Pi{r^2}$

使用 evalf() 函数通过将 r 替换为 5 来计算上述表达式

>>> 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）的名称。默认情况下，对数学标准库中的实现进行lambdaify。

>>> expr=1/sin(x) 
>>> f=lambdify(x, expr) 
>>> f(3.14)

上面的代码片段给出了以下输出 -

627.8831939138764

该表达式可能有多个变量。在这种情况下，lambdaify() 函数的第一个参数是变量列表，后跟要计算的表达式。

>>> expr=a**2+b**2 
>>> f=lambdify([a,b],expr) 
>>> f(2,3)

上面的代码片段给出了以下输出 -

13

然而，为了利用 numpy 库作为数字后端，我们必须将其定义为lambdaify()函数的参数。

>>> f=lambdify([a,b],expr, "numpy")

我们在上面的函数中使用两个 numpy 数组作为两个参数 a 和 b。对于 numpy 数组，执行时间相当快。

>>> import numpy 
>>> l1=numpy.arange(1,6) 
>>> l2=numpy.arange(6,11) 
>>> f(l1,l2)

上面的代码片段给出了以下输出 -

数组([ 37, 53, 73, 97, 125], dtype=int32)

SymPy - 逻辑表达式

布尔函数在sympy.basic.booleanarg 模块中定义。可以使用标准 python 运算符 & (And)、| 构建布尔表达式。（或）、~（非）以及 >> 和 <<。布尔表达式继承自 SymPy 核心模块中定义的 Basic 类。

布尔真函数

该函数相当于核心 Python 中的 True。它返回一个可由 S.true 检索的单例。

>>> from sympy import * 
>>> x=sympify(true) 
>>> x, S.true

上面的代码片段给出了以下输出 -

（真实，真实）

布尔值False 函数

同样，该函数相当于Python中的Boolean False，可以通过S.false访问

>>> from sympy import * 
>>> x=sympify(false) 
>>> x, S.false

上面的代码片段给出了以下输出 -

（假，假）

及功能

逻辑 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

上面的代码片段给出了以下输出 -

（真实，真实）

>>> y=False 
>>> And(x,y), x"&"y

上面的代码片段给出了以下输出 -

（假，假）

或者函数

此函数计算两个布尔参数，如果其中任何一个为 True，则返回 True。| 的 | 操作员可以方便地模拟其Behave。

>>> from sympy import * 
>>> from sympy.logic.boolalg import Or 
>>> x,y=symbols('x y') 
>>> x=True 
>>> y=False 
>>> Or(x,y), x|y

上面的代码片段给出了以下输出 -

（真实，真实）

>>> x=False 
>>> y=False 
>>> Or(x,y), x|y

上面的代码片段给出了以下输出 -

（假，假）

不是功能

逻辑非函数导致布尔参数取反。如果其参数为 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)

上面的代码片段给出了以下输出 -

（假，真）

>>> Not(And(x,y)), Not(Or(x,y))

上面的代码片段给出了以下输出 -

（真假）

异或函数

如果奇数个参数为 True，其余为 False，逻辑 XOR（异或）函数返回 True；如果偶数个参数为 True，其余为 False，则返回 False。^ 运算符执行类似的操作。

>>> from sympy import * 
>>> from sympy.logic.boolalg import Xor 
>>> x,y=symbols('x y') 
>>> x=True 
>>> y=False

>>> Xor(x,y), x^y

上面的代码片段给出了以下输出 -

（真实，真实）

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

上面的代码片段给出了以下输出 -

真的

在上面的例子中，三个（奇数）参数为 True，因此 Xor 返回 true。但是，如果 True 参数的数量是偶数，则会导致 False，如下所示 -

>>> a,b,c,d,e=(True, False, False, True, False) 
>>> Xor(a,b,c,d,e)

上面的代码片段给出了以下输出 -

错误的

与非函数

该函数执行逻辑 NAND 操作。它评估其参数，如果其中任何一个为 False，则返回 True；如果全部为 True，则返回 False。

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

上面的代码片段给出了以下输出 -

（真假）

也没有功能

该函数执行逻辑或非运算。它评估其参数，如果其中任何一个为 True，则返回 False；如果全部为 False，则返回 True。

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

上面的代码片段给出了以下输出 -

（假，假）

请注意，即使 SymPy 为 Xor 提供 ^ 运算符，为 Not 提供 ~ 运算符，| 为了方便起见，对于 Or 和 & 对于 And 函数，它们在 Python 中的正常用法是作为位运算符。因此，如果操作数是整数，结果将会不同。

等效功能

该函数返回等价关系。当且仅当 A 和 B 均为 True 或均为 False 时，Equivalent(A, B) 才为 True。如果所有参数在逻辑上相等，则该函数返回 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)

上面的代码片段给出了以下输出 -

（假，真）

ITE功能

此函数充当编程语言中的 If then else 子句。ITE(A, B, C) 计算并返回 B 的结果，如果 A 为 true，则返回 C 的结果。所有参数必须为布尔值。

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

上面的代码片段给出了以下输出 -

（假，真）

SymPy - 查询

SymPy 包中的假设模块包含用于提取表达式信息的工具。为此，模块定义了ask()函数。

sympy.assumptions.ask(property)

以下属性提供有关表达式的有用信息 -

代数(x)

为了成为代数，一个数必须是具有有理系数的非零多项式方程的根。√2 因为 √2 是 x2 − 2 = 0 的解，所以它是代数的。

复数(x)

复数谓词。当且仅当 x 属于复数集合时才为真。

复合材料(x)

当且仅当 x 是正整数并且至少有一个除 1 和数字本身之外的正除数时，ask(Q.composite(x)) 返回的合数谓词为 true。

偶数、奇数

当 x 位于偶数集合和奇数集合中时，ask() 分别返回 true。

假想

该属性表示虚数谓词。如果 x 可以写为实数乘以虚数单位 I，则成立。

整数

Q.integer(x) 返回的此属性返回 true，表示 x 属于偶数集。

理性的、非理性的

当且仅当 x 是任何不能表示为整数比的实数时，Q.irrational(x) 才为 true。例如，pi 是一个无理数。

正负

检查数字是正数还是负数的谓词

零、非零

判断数字是否为零

>>> from sympy import * 
>>> x=Symbol('x') 
>>> x=10 
>>> ask(Q.algebraic(pi))
False
>>> ask(Q.complex(5-4*I)), ask( Q.complex(100))
(True, True)
>>> x,y=symbols("x y") 
>>> x,y=5,10 
>>> ask(Q.composite(x)), ask(Q.composite(y))
(False, True)
>>> ask(Q.even(x)), ask(Q.even(y))
(False, True)
>>> x,y= 2*I, 4+5*I 
>>> ask(Q.imaginary(x)), ask(Q.imaginary(y))
(True, False)
>>> x,y=5,10 
>>> ask(Q.even(x)), ask(Q.even(y)), ask(Q.odd(x)), ask(Q.odd(y))
(False, True, True, False)
>>> x,y=5,-5 
>>> ask(Q.positive(x)), ask(Q.negative(y)), ask(Q.positive(x)), ask(Q.negative(y))
(True, True, True, True)
>>> ask(Q.rational(pi)), ask(Q.irrational(S(2)/3))
(False, False)
>>> ask(Q.zero(oo)), ask(Q.nonzero(I))
(False, False)

SymPy - 简化

Sympy 具有强大的简化数学表达式的能力。SymPy 中有许多函数可以执行各种简化。一个名为 simple() 的通用函数尝试得出表达式的最简单形式。

简化

该函数在 sympy.simplify 模块中定义。simple() 尝试应用智能启发法使输入表达式“更简单”。以下代码显示了简化表达式 $sin^2(x)+cos^2(x)$。

>>> from sympy import * 
>>> x=Symbol('x')
>>> expr=sin(x)**2 + cos(x)**2 
>>> simplify(expr)

上面的代码片段给出了以下输出 -

1

扩张

Expand() 是 SymPy 中最常见的简化函数之一，用于展开多项式表达式。例如 -

>>> a,b=symbols('a b') 
>>> expand((a+b)**2)

上面的代码片段给出了相当于下面表达式的输出 -

$a^2 + 2ab + b^2$

>>> expand((a+b)*(a-b))

上面的代码片段给出了相当于下面表达式的输出 -

$a^2 - b^2$

Expand() 函数使表达式变大，而不是变小。通常情况就是这样，但在调用 Expand() 时，表达式通常会变得更小。

>>> expand((x + 1)*(x - 2) - (x - 1)*x)

上面的代码片段给出了以下输出 -

-2

因素

该函数采用多项式并将其分解为有理数上的不可约因子。

>>> x,y,z=symbols('x y z') 
>>> expr=(x**2*z + 4*x*y*z + 4*y**2*z) 
>>> factor(expr)

上面的代码片段给出了相当于下面表达式的输出 -

$z(x + 2y)^2$

>>> factor(x**2+2*x+1)

上面的代码片段给出了相当于下面表达式的输出 -

$(x + 1)^2$

Factor() 函数与expand() 相反。Factor() 返回的每个因子都保证是不可约的。Factor_list() 函数返回更结构化的输出。

>>> expr=(x**2*z + 4*x*y*z + 4*y**2*z) 
>>> factor_list(expr)

上面的代码片段给出了相当于下面表达式的输出 -

(1, [(z, 1), (x + 2*y, 2)])

收集

此函数收集表达式的加法项，该表达式涉及到有理指数幂的表达式列表。

>>> expr=x*y + x - 3 + 2*x**2 - z*x**2 + x**3 
>>> expr

上面的代码片段给出了相当于下面表达式的输出 -

$x^3 + x^2z + 2x^2 + xy + x - 3$

该表达式上的collect()函数结果如下 -

>>> collect(expr,x)

上面的代码片段给出了相当于下面表达式的输出 -

$x^3 + x^2(2 - z) + x(y + 1) - 3$

>>> expr=y**2*x + 4*x*y*z + 4*y**2*z+y**3+2*x*y 
>>> collect(expr,y)

上面的代码片段给出了相当于下面表达式的输出 -

$Y^3+Y^2(x+4z)+y(4xz+2x)$

取消

cancel() 函数将采用任何有理函数并将其放入标准规范形式 p/q，其中 p 和 q 是没有公因子的展开多项式。p 和 q 的前导系数没有分母，即它们是整数。

>>> expr1=x**2+2*x+1 
>>> expr2=x+1 
>>> cancel(expr1/expr2)

上面的代码片段给出了相当于下面表达式的输出 -

$x+1$

>>> expr = 1/x + (3*x/2 - 2)/(x - 4) 
>>> expr

上面的代码片段给出了相当于下面表达式的输出 -

$\frac{\frac{3x}{2} - 2}{x - 4} + \frac{1}{x}$

>>> cancel(expr)

上面的代码片段给出了相当于下面表达式的输出 -

$\frac{3x^2 - 2x - 8}{2x^2 - 8}$

>>> expr=1/sin(x)**2 
>>> expr1=sin(x) 
>>> cancel(expr1*expr)

上面的代码片段给出了相当于下面表达式的输出 -

$\frac{1}{\sin(x)}$

特里格辛普

该函数用于简化三角恒等式。可能需要注意的是，反三角函数的命名约定是在函数名称前面附加 a。例如，反余弦或反余弦称为 acos()。

>>> from sympy import trigsimp, sin, cos 
>>> from sympy.abc import x, y
>>> expr = 2*sin(x)**2 + 2*cos(x)**2 
>>> trigsimp(expr)

2

trigsimp 函数使用启发式方法来应用最合适的三角恒等式。

功率简化

该函数通过组合具有相似底数和指数的幂来简化给定的表达式。

>>> expr=x**y*x**z*y**z 
>>> expr

上面的代码片段给出了相当于下面表达式的输出 -

$x^yx^zy^z$

>>> powsimp(expr)

上面的代码片段给出了相当于下面表达式的输出 -

$x^{y+z} y^z$

您可以通过更改combine='base'或combine='exp'来使powsimp()仅组合基数或仅组合指数。默认情况下，combine='all'，两者兼而有之。如果force为True，则将组合碱基而不检查假设。

>>> powsimp(expr, combine='base', force=True)

上面的代码片段给出了相当于下面表达式的输出 -

$x^y(xy)^z$

梳子

涉及阶乘和二项式的组合表达式可以使用combsimp()函数进行简化。SymPy提供了一个factorial()函数

>>> expr=factorial(x)/factorial(x - 3) 
>>> expr

上面的代码片段给出了相当于下面表达式的输出 -

$\frac{x!}{(x - 3)!}$

为了简化上面的组合表达式，我们使用 Combsimp() 函数，如下所示 -

>>> combsimp(expr)

上面的代码片段给出了相当于下面表达式的输出 -

$x(x-2)(x-1)$

二项式(x, y) 是从一组 x 个不同项目中选择 y 个项目的方法数。它也常写为 xCy。

>>> binomial(x,y)

上面的代码片段给出了相当于下面表达式的输出 -

$(\frac{x}{y})$

>>> combsimp(binomial(x+1, y+1)/binomial(x, y))

上面的代码片段给出了相当于下面表达式的输出 -

$\frac{x + 1}{y + 1}$

对数组合

该函数采用对数并使用以下规则组合它们 -

• log(x) + log(y) == log(x*y) 如果两者均为正数
• a*log(x) == log(x**a) 如果 x 为正且 a 为实数

>>> logcombine(a*log(x) + log(y) - log(z))

上面的代码片段给出了相当于下面表达式的输出 -

$a\log(x) + \log(y) - \log(z)$

如果该函数的力参数设置为 True，则在数量上没有假设的情况下，上述假设将被假设成立。

>>> logcombine(a*log(x) + log(y) - log(z), force=True)

上面的代码片段给出了相当于下面表达式的输出 -

$\log\frac{x^ay}{z}$

SymPy - 导数

函数的导数是其相对于其中一个变量的瞬时变化率。这相当于求函数在一点的切线的斜率。我们可以使用SymPy包中的diff()函数来求以变量形式存在的数学表达式的微分。

diff(expr, variable)
>>> from sympy import diff, sin, exp 
>>> from sympy.abc import x,y 
>>> expr=x*sin(x*x)+1 >>> expr

上面的代码片段给出了相当于下面表达式的输出 -

$x\sin(x^2) + 1$

>>> diff(expr,x)

上面的代码片段给出了相当于下面表达式的输出 -

$2x^2\cos(x^2) + \sin(x^2)$

>>> diff(exp(x**2),x)

上面的代码片段给出了相当于下面表达式的输出 -

2 ×2 ^{× 2}

要获取多重导数，请根据需要多次传递变量以求微分，或在变量后传递一个数字。

>>> diff(x**4,x,3)

上面的代码片段给出了相当于下面表达式的输出 -

$24x$

>>> for i in range(1,4): print (diff(x**4,x,i))

上面的代码片段给出了下面的表达式 -

4*x**3

12*x**2

24*x

也可以调用表达式的 diff() 方法。它的工作原理与 diff() 函数类似。

>>> expr=x*sin(x*x)+1 
>>> expr.diff(x)

上面的代码片段给出了相当于下面表达式的输出 -

$2x^2\cos(x^2) + \sin(x^2)$

未计算的导数是使用 Derivative 类创建的。它与 diff() 函数具有相同的语法。要评估未评估的导数，请使用 doit 方法。

>>> from sympy import Derivative 
>>> d=Derivative(expr) 
>>> d

上面的代码片段给出了相当于下面表达式的输出 -

$\frac{d}{dx}(x\sin(x^2)+1)$

>>> d.doit()

上面的代码片段给出了相当于下面表达式的输出 -

$2x^2\cos(x^2) + \sin(x^2)$

SymPy - 集成

SymPy 包包含积分模块。它实现了计算表达式的定积分和不定积分的方法。Integrate() 方法用于计算定积分和不定积分。要计算不定积分或原始积分，只需在表达式后面传递变量即可。

例如 -

integrate(f, x)

要计算定积分，请按如下方式传递参数 -

(integration_variable, lower_limit, upper_limit)

>>> from sympy import * 
>>> x,y = symbols('x y') 
>>> expr=x**2 + x + 1 
>>> integrate(expr, x)

上面的代码片段给出了相当于下面表达式的输出 -

$\frac{x^3}{3} + \frac{x^2}{2} + x$

>>> expr=sin(x)*tan(x) 
>>> expr 
>>> integrate(expr,x)

上面的代码片段给出了相当于下面表达式的输出 -

$-\frac{\log(\sin(x) - 1)}{2} + \frac{\log(\sin(x) + 1)}{2} - \sin(x)$

定积分的例子如下 -

>>> expr=exp(-x**2) 
>>> integrate(expr,(x,0,oo) )

上面的代码片段给出了相当于下面表达式的输出 -

$\frac{\sqrt\pi}{2}$

您可以传递多个极限元组来执行多重积分。下面给出一个例子 -

>>> expr=exp(-x**2 - y**2)
>>> integrate(expr,(x,0,oo),(y,0,oo))

上面的代码片段给出了相当于下面表达式的输出 -

$\frac{\pi}{4}$

您可以使用 Integral 对象创建未计算的积分，该对象可以通过调用 doit() 方法进行计算。

>>> expr = Integral(log(x)**2, x) 
>>> expr

上面的代码片段给出了相当于下面表达式的输出 -

$\int \mathrm\log(x)^2 \mathrm{d}x$

>>> expr.doit()

上面的代码片段给出了相当于下面表达式的输出 -

$x\log(x)^2 - 2xlog(x) + 2x$

积分变换

SymPy 支持各种类型的积分变换，如下所示 -

• 拉普拉斯变换
• 傅里叶变换
• 正弦变换
• 余弦变换
• 汉克尔变换

这些函数在 sympy.integrals.transforms 模块中定义。以下示例分别计算傅里叶变换和拉普拉斯变换。

实施例1

>>> from sympy import fourier_transform, exp 
>>> from sympy.abc import x, k 
>>> expr=exp(-x**2) 
>>> fourier_transform(expr, x, k)

在 python shell 中执行上述命令时，将生成以下输出 -

sqrt(pi)*exp(-pi**2*k**2)

这相当于 -

$\sqrt\pi * e^{\pi^2k^2}$

实施例2

>>> from sympy.integrals import laplace_transform 
>>> from sympy.abc import t, s, a 
>>> laplace_transform(t**a, t, s)

在 python shell 中执行上述命令时，将生成以下输出 -

(s**(-a)*gamma(a + 1)/s, 0, re(a) > -1)

SymPy - 矩阵

在数学中，矩阵是数字、符号或表达式的二维数组。矩阵运算理论涉及在遵守某些规则的情况下对矩阵对象执行算术运算。

线性变换是矩阵的重要应用之一。许多科学领域，特别是与物理学相关的领域都使用矩阵相关的应用程序。

SymPy 包具有处理矩阵处理的矩阵模块。它包括 Matrix 类，其对象表示矩阵。

注意：如果您想单独执行本章中的所有片段，您需要导入矩阵模块，如下所示 -

>>> from sympy.matrices import Matrix

例子

>>> from sympy.matrices import Matrix 
>>> m=Matrix([[1,2,3],[2,3,1]]) 
>>> m
$\displaystyle \left[\begin{matrix}1 & 2 & 3\\2 & 3 & 1\end{matrix}\right]$

在 python shell 中执行上述命令时，将生成以下输出 -

[1 2 3 2 3 1]

矩阵是从适当大小的列表对象创建的。您还可以通过将列表项分布在指定数量的行和列中来获取矩阵。

>>> M=Matrix(2,3,[10,40,30,2,6,9]) 
>>> M
$\displaystyle \left[\begin{matrix}10 & 40 & 30\\2 & 6 & 9\end{matrix}\right]$

在 python shell 中执行上述命令时，将生成以下输出 -

[10 40 30 2 6 9]

矩阵是一个可变对象。矩阵模块还提供了 ImmutableMatrix 类来获取不可变矩阵。

基本操控

Matrix 对象的shape属性返回其大小。

>>> M.shape

上述代码的输出如下 -

(2,3)

row() 和 col() 方法分别返回指定数量的行或列。

>>> M.row(0)
$\displaystyle \left[\begin{matrix}10 & 40 & 30\end{matrix}\right]$

上述代码的输出如下 -

[10 40 30]

>>> M.col(1)
$\displaystyle \left[\begin{matrix}40\\6\end{matrix}\right]$

上述代码的输出如下 -

[40 6]

使用 Python 的切片运算符来获取属于行或列的一项或多项。

>>> M.row(1)[1:3]
[6, 9]

Matrix 类具有 row_del() 和 col_del() 方法，可从给定矩阵中删除指定的行/列 -

>>> M=Matrix(2,3,[10,40,30,2,6,9]) 
>>> M.col_del(1) 
>>> M

在 python shell 中执行上述命令时，将生成以下输出 -

Matrix([[10, 30],[ 2, 9]])

您可以使用以下命令将样式应用于输出 -

$\displaystyle \left[\begin{matrix}10 & 30\\2 & 9\end{matrix}\right]$

执行上述代码片段后，您将得到以下输出 -

[10 30 2 9]

>>> M.row_del(0) 
>>> M

$\displaystyle \left[\begin{matrix}2 & 9\end{matrix}\right]$

执行上述代码片段后，您将得到以下输出 -

[2 9]

类似地，row_insert() 和 col_insert() 方法在指定的行或列索引处添加行或列

>>> M1=Matrix([[10,30]]) 
>>> M=M.row_insert(0,M1)
>>> M

$\displaystyle \left[\begin{matrix}10 & 30\\2 & 9\end{matrix}\right]$

执行上述代码片段后，您将得到以下输出 -

[10 40 30 2 9]

>>> M2=Matrix([40,6]) 
>>> M=M.col_insert(1,M2) 
>>> M

$\displaystyle \left[\begin{matrix}10 & 40 & 30\\2 & 6 & 9\end{matrix}\right]$

执行上述代码片段后，您将得到以下输出 -

[10 40 30 6 9]

算术运算

定义常用运算符 +、- 和 * 来执行加法、减法和乘法。

>>> M1=Matrix([[1,2,3],[3,2,1]]) 
>>> M2=Matrix([[4,5,6],[6,5,4]]) 
>>> M1+M2

$\displaystyle \left[\begin{matrix}5 & 7 & 9\\9 & 7 & 5\end{matrix}\right]$

执行上述代码片段后，您将得到以下输出 -

[5 7 9 9 7 5]

>>> M1-M2
$\displaystyle \left[\begin{matrix}-3 & -3 & -3\\-3 & -3 & -3\end{matrix}\right]$

执行上述代码片段后，您将得到以下输出 -

[- 3 -3 -3 -3 -3 -3]

仅当满足以下条件时，矩阵乘法才可行： - 第一个矩阵的列数必须等于第二个矩阵的行数。- 结果将具有与第一个矩阵相同的行数，以及与第二个矩阵相同的列数。

>>> M1=Matrix([[1,2,3],[3,2,1]]) 
>>> M2=Matrix([[4,5],[6,6],[5,4]]) 
>>> M1*M2
$\displaystyle \left[\begin{matrix}31 & 29\\29 & 31\end{matrix}\right]$

上述代码的输出如下 -

[31 29 29 31]

>>> M1.T
$\displaystyle \left[\begin{matrix}1 & 3\\2 & 2\\3 & 1\end{matrix}\right]$

执行代码后获得以下输出 -

[1 3 2 2 3 1]

要计算矩阵的行列式，请使用 det() 方法。行列式是一个标量值，可以根据方阵的元素计算出来。0

>>> M=Matrix(3,3,[10,20,30,5,8,12,9,6,15])
>>> M
$\displaystyle \left[\begin{matrix}10 & 20 & 30\\5 & 8 & 12\\9 & 6 & 15\end{matrix}\right]$

上述代码的输出如下 -

[10 20 30 5 8 12 9 6 15]

>>> M.det()

上述代码的输出如下 -

-120

矩阵构造函数

SymPy 提供了许多特殊类型的矩阵类。例如，单位矩阵、全零和全一的矩阵等。这些类分别被命名为eye、zeros和one。单位矩阵是一个方阵，对角线上的元素设置为1，其余元素设置为0。

例子

from sympy.matrices import eye eye(3)

输出

Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])

$\displaystyle \left[\begin{matrix}1 & 0 & 0\\0 & 1 & 0\\0 & 0 & 1\end{matrix}\right]$

上述代码的输出如下 -

[1 0 0 0 1 0 0 0 1]

在对角矩阵中，对角线上的元素根据提供的参数进行初始化。

>>> from sympy.matrices import diag 
>>> diag(1,2,3)

$\displaystyle \left[\begin{matrix}1 & 0 & 0\\0 & 2 & 0\\0 & 0 & 3\end{matrix}\right]$

上述代码的输出如下 -

[1 0 0 0 2 0 0 0 3]

零矩阵中的所有元素都初始化为 0。

>>> from sympy.matrices import zeros 
>>> zeros(2,3)

$\displaystyle \left[\begin{matrix}0 & 0 & 0\\0 & 0 & 0\end{matrix}\right]$

上述代码的输出如下 -

[0 0 0 0 0 0]

同样，ones 是所有元素都设置为 1 的矩阵。

>>> from sympy.matrices import ones
>>> ones(2,3)

$\displaystyle \left[\begin{matrix}1 & 1 & 1\\1 & 1 & 1\end{matrix}\right]$

上述代码的输出如下 -

[1 1 1 1 1 1]

SymPy - 函数类

Sympy包有Function类，它在sympy.core.function模块中定义。它是所有应用数学函数的基类，也是未定义函数类的构造函数。

以下类别的函数继承自 Function 类 -

• 复数函数
• 三角函数
• 整数函数
• 组合函数
• 其他杂项功能

复数函数

这组函数在sympy.functions.elementary.complexes模块中定义。

关于

该函数返回表达式的实部 -

>>> from sympy import * 
>>> re(5+3*I)

上述代码片段的输出如下 -

5

>>> re(I)

上述代码片段的输出是 -

0

我是

该函数返回表达式的虚部 -

>>> im(5+3*I)

上述代码片段的输出如下 -

3

>>> im(I)

上述代码片段的输出如下 -

1

符号

该函数返回表达式的复数符号。

对于真实的表达，符号将是 -

• 1 如果表达式为正
• 如果表达式等于 0，则为 0
• 如果表达式为负数，则为 -1

如果表达式是虚数，则返回的符号为 -

• I 如果 im(表达式) 为正
• -I 如果 im(表达式) 为负数

>>> sign(1.55), sign(-1), sign(S.Zero)

上述代码片段的输出如下 -

(1, -1, 0)

>>> sign (-3*I), sign(I*2)

上述代码片段的输出如下 -

（-我，我）

腹肌

该函数返回复数的绝对值。它定义为复平面中原点 (0,0) 和点 (a,b) 之间的距离。该函数是内置函数 abs() 的扩展，用于接受符号值。

>>> Abs(2+3*I)

上述代码片段的输出如下 -

$\sqrt13$

共轭

该函数返回复数的共轭。为了找到复共轭，我们改变虚部的符号。

>>> conjugate(4+7*I)

执行上述代码片段后，您将得到以下输出 -

4 - 7我

三角函数

SymPy 具有所有三角比率的定义 - sin cos、tan 等及其反函数，如 asin、acos、atan 等。这些函数计算以弧度表示的给定角度的相应值。

>>> sin(pi/2), cos(pi/4), tan(pi/6)

上述代码片段的输出如下 -

(1、开方(2)/2、开方(3)/3)

>>> asin(1), acos(sqrt(2)/2), atan(sqrt(3)/3)

上述代码片段的输出如下 -

（圆周率/2、圆周率/4、圆周率/6）

整数函数

这是一组对整数执行各种操作的函数。

天花板

这是一个单变量函数，返回不小于其参数的最小整数值。对于复数，实部和虚部的上限分别。

>>> ceiling(pi), ceiling(Rational(20,3)), ceiling(2.6+3.3*I)

上述代码片段的输出如下 -

(4, 7, 3 + 4*I)

地面

该函数返回不大于其参数的最大整数值。对于复数，该函数也分别取实部和虚部的底数。

>>> floor(pi), floor(Rational(100,6)), floor(6.3-5.9*I)

上述代码片段的输出如下 -

(3, 16, 6 - 6*I)

压裂

该函数表示 x 的小数部分。

>>> frac(3.99), frac(Rational(10,3)), frac(10)

上述代码片段的输出如下 -

(0.990000000000000, 1/3, 0)

组合函数

组合学是一个数学领域，涉及有限或离散系统内的选择、排列和运算问题。

阶乘

阶乘在组合数学中非常重要，它给出了 n 个对象可以排列的方式数量。它象征性地表示为 ð '¥! 该函数是非负整数阶乘函数的实现，负整数的阶乘是复无穷大。

>>> x=Symbol('x') 
>>> factorial(x)

上述代码片段的输出如下 -

X！

>>> factorial(5)

上述代码片段的输出如下 -

120

>>> factorial(-1)

上述代码片段的输出如下 -

$\infty\backsim$

二项式

该函数表示我们可以从 n 个元素的集合中选择 k 个元素的方法数。

>>> x,y=symbols('x y') 
>>> binomial(x,y)

上述代码片段的输出如下 -

$(\frac{x}{y})$

>>> binomial(4,2)

上述代码片段的输出如下 -

6

帕斯卡三角形的行可以用二项式函数生成。

>>> for i in range(5): print ([binomial(i,j) for j in range(i+1)])

执行上述代码片段后，您将得到以下输出 -

[1]

[1, 1]

[1,2,1]

[1,3,3,1]

[1,4,6,4,1]

斐波那契

斐波那契数列是由初始项 F0=0、F1=1 和两项递推关系 Fn=Fn−1+Fn−2 定义的整数序列。

>>> [fibonacci(x) for x in range(10)]

执行上述代码片段后获得以下输出 -

[0、1、1、2、3、5、8、13、21、34]

特里博纳奇

Tribonacci数是由初始项F0=0、F1=1、F2=1和三项递推关系Fn=Fn-1+Fn-2+Fn-3定义的整数序列。

>>> tribonacci(5, Symbol('x'))

上面的代码片段给出了相当于下面表达式的输出 -

$x^8 + 3x^5 + 3x^2$

>>> [tribonacci(x) for x in range(10)]

执行上述代码片段后获得以下输出 -

[0、1、1、2、4、7、13、24、44、81]

杂项功能

以下是一些常用功能的列表 -

Min - 返回列表的最小值。它被命名为 Min 是为了避免与内置函数 min 冲突。

Max - 返回列表的最大值。它被命名为Max是为了避免与内置函数max冲突。

root - 返回 x 的 n 次方根。

sqrt - 返回 x 的主平方根。

cbrt - 该函数计算 x 的主立方根（x++Rational(1,3) 的快捷方式）。

以下是上述杂项功能及其各自输出的示例 -

>>> Min(pi,E)

e

>>> Max(5, Rational(11,2))

$\frac{11}{2}$

>>> root(7,Rational(1,2))

49

>>> sqrt(2)

$\sqrt2$

>>> cbrt(1000)

10

SymPy - 四元数

在数学中，四元数系统是复数的扩展。每个四元数对象包含四个标量变量和四个维度，一个实数维度和三个虚数维度。

四元数由以下表达式表示 -

q=a+bi+cj+dk

其中a、b、c和 d 是实数，i、j、k是四元数单位，使得 i2==j2==k2==ijk

sympy.algebras.quaternion模块具有 Quaternion 类。

>>> from sympy.algebras.quaternion import Quaternion 
>>> q=Quaternion(2,3,1,4) 
>>> q

上面的代码片段给出了相当于下面表达式的输出 -

$2 + 3i + 1j + 4k$

四元数用于纯数学，也用于应用数学、计算机图形学、计算机视觉等。

>>> from sympy import * 
>>> x=Symbol('x') 
>>> q1=Quaternion(x**2, x**3, x) >>> q1

上面的代码片段给出了相当于下面表达式的输出 -

$x^2 + x^3i + xj + 0k$

四元数对象也可以有虚数系数

>>> q2=Quaternion(2,(3+2*I), x**2, 3.5*I) 
>>> q2

上面的代码片段给出了相当于下面表达式的输出 -

$2 + (3 + 2i)i + x2j + 3.5ik$

添加（）

Quaternion 类中提供的此方法执行两个 Quaternion 对象的加法。

>>> q1=Quaternion(1,2,3,4) 
>>> q2=Quaternion(4,3,2,1) 
>>> q1.add(q2)

上面的代码片段给出了相当于下面表达式的输出 -

$5 + 5i + 5j + 5k$

可以在四元数对象中添加数字或符号。

>>> q1+2

执行上述代码片段后获得以下输出 -

$3 + 2i + 3j + 4k$

>>> q1+x

执行上述代码片段后获得以下输出 -

$(x + 1) + 2i + 3j + 4k$

乘法（）

该方法执行两个 q 的乘法