SymPy 快速指南

---

---

SymPy - 简介

SymPy 是一个用于执行符号计算的 Python 库。它是一个计算机代数系统 (CAS)，可以作为独立应用程序使用，也可以作为其他应用程序的库使用。它的实时会话也提供在 https://live.sympy.cn/。因为它是一个纯 Python 库，所以它可以作为交互模式和程序化应用程序使用。SymPy 现在已成为科学 Python 生态系统中流行的符号库。

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

SymPy 的一些应用领域包括：

• 多项式
• 微积分
• 离散数学
• 矩阵
• 几何
• 绘图
• 物理
• 统计
• 组合数学

SymPy - 安装

SymPy 有一个重要的先决条件库，名为mpmath。它是一个用于任意精度实数和复数浮点运算的 Python 库。但是，Python 的包安装程序 PIP 会在安装 SymPy 时自动安装它，如下所示：

pip install sympy

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

>>> import sympy
>>> sympy.__version__

您将获得以下输出作为 sympy 的当前版本：

'1.5.1'

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

SymPy - 符号计算

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

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

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

5.0 2.6457513110645907

如您所见，7 的平方根是近似计算的。但在 SymPy 中，默认情况下，非完全平方数的平方根保持未计算，如下所示：

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

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

sqrt(7)

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

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

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

3.4641016151377544

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

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

其输出如下：

2*sqrt(3)

在 Jupyter Notebook 中运行时，SymPy 代码使用 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 包中的核心模块包含 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 类表示任何大小的整数。构造函数可以接受 Float 或 Rational 数，但小数部分将被丢弃

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

其他预定义的单例数字对象是 Half、NaN、Infinity 和 ImaginaryUnit

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

输出如下：

½

>>> print (S.NaN)

输出如下：

nan

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

>>> from sympy import oo 
>>> oo

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

$\infty$

>>> S.Infinity

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

$\infty$

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

>>> from sympy import I 
>>> I

执行上述代码片段时，您将获得以下输出：

i

>>> S.ImaginaryUnit

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

i

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

上述代码片段给出的输出等效于以下表达式：

$side^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 命名空间中定义的特殊名称。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 是一个数字，则所有左侧的连续数字都被视为非负起始值。所有右侧的连续数字都被视为结束值加 1。

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

上述代码片段给出的输出等效于以下表达式：

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

>>> expr.subs(x,a)

上述代码片段给出的输出等效于以下表达式：

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

如果我们想计算某个表达式的值，此函数很有用。例如，我们想通过用 5 代替 a 来计算以下表达式的值。

>>> 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。* evaluate：如果设置为 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}$

要通过用 5 替换 r 来使用 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")

我们在上面的函数中使用两个 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 - 逻辑表达式

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

BooleanTrue 函数

此函数等效于核心 Python 中的 True。它返回一个单例，可以通过 S.true 获取。

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

上述代码片段给出以下输出：

(True, True)

BooleanFalse 函数

类似地，此函数等效于 Python 中的布尔值 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 函数

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

逻辑异或 (XOR) 函数如果奇数个参数为 True，其余为 False，则返回 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

上述代码片段给出以下输出：

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

上述代码片段给出以下输出：

True

在上述情况下，三个（奇数）参数为 True，因此 Xor 返回 true。但是，如果 True 参数的个数为偶数，则结果为 False，如下所示：

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

上述代码片段给出以下输出：

False

Nand 函数

此函数执行逻辑 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)

Nor 函数

此函数执行逻辑 NOR 操作。它计算其参数，如果任何一个参数为 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)

上述代码片段给出以下输出：

(False, False)

请注意，尽管 SymPy 提供了 ^ 运算符用于 Xor，~ 用于 Not，| 用于 Or，& 用于 And 函数作为方便之举，但它们在 Python 中的常规用法是位运算符。因此，如果操作数是整数，结果将有所不同。

Equivalent 函数

此函数返回等价关系。Equivalent(A, B) 当且仅当 A 和 B 都为 True 或都为 False 时为 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)

上述代码片段给出以下输出：

(False, True)

ITE 函数

此函数在编程语言中充当 If then else 子句。ITE(A, B, C) 计算并返回 B 的结果（如果 A 为真），否则返回 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)

上述代码片段给出以下输出：

(False, True)

SymPy - 查询

SymPy 包中的 assumptions 模块包含用于提取有关表达式信息的工具。该模块为此目的定义了 ask() 函数。

sympy.assumptions.ask(property)

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

algebraic(x)

要成为代数数，一个数必须是非零多项式方程（具有有理系数）的根。√2 是代数数，因为 √2 是 x² - 2 = 0 的解。

complex(x)

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

composite(x)

由 ask(Q.composite(x)) 返回的合数谓词当且仅当 x 是正整数且至少有一个除 1 和自身以外的正约数时为真。

even, odd

ask() 分别返回 x 是否属于偶数集和奇数集。

imaginary

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

integer

Q.integer(x) 返回的此属性如果 x 属于偶数集则返回 true。

rational, irrational

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

positive, negative

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

zero, nonzero

用于检查数字是否为零的谓词

>>> 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 中有许多函数可以执行各种简化。有一个名为 simplify() 的通用函数，它尝试得到表达式最简单的形式。

simplify

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

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

上述代码片段给出以下输出：

1

expand

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

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

上述代码片段给出的输出等效于以下表达式：

a² + 2ab + b²

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

上述代码片段给出的输出等效于以下表达式：

a² - b²

expand() 函数使表达式变大，而不是变小。通常情况下是这样，但有时在调用 expand() 后，表达式会变小。

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

上述代码片段给出以下输出：

-2

factor

此函数接受一个多项式并将其分解为有理数上的不可约因子。

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

上述代码片段给出的输出等效于以下表达式：

z(x + 2y)²

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

上述代码片段给出的输出等效于以下表达式：

(x + 1)²

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

collect

此函数根据表达式列表收集表达式的加法项，直到具有有理指数的幂。

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

上述代码片段给出的输出等效于以下表达式：

x³ + x²z + 2x² + xy + x - 3

对该表达式进行 collect() 函数处理后的结果如下：

>>> collect(expr,x)

上述代码片段给出的输出等效于以下表达式：

x³ + x²(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³ + Y²(x + 4z) + y(4xz + 2x)

cancel

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

上述代码片段给出的输出等效于以下表达式：

(3x/2 - 2) / (x - 4) + 1/x

>>> cancel(expr)

上述代码片段给出的输出等效于以下表达式：

(3x² - 2x - 8) / (2x² - 8)

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

上述代码片段给出的输出等效于以下表达式：

1/sin(x)

trigsimp

此函数用于简化三角恒等式。需要注意的是，反三角函数的命名约定是在函数名前添加一个 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 函数使用启发式方法应用最合适的三角恒等式。

powersimp

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

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

上述代码片段给出的输出等效于以下表达式：

xʸxᶻyᶻ

>>> powsimp(expr)

上述代码片段给出的输出等效于以下表达式：

xʸ⁺ᶻyᶻ

可以通过将 combine='base' 或 combine='exp' 来使 powsimp() 只组合底数或只组合指数。默认情况下，combine='all'，两者都做。如果 force 为 True，则将在不检查假设的情况下组合底数。

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

上述代码片段给出的输出等效于以下表达式：

xʸ(xy)ᶻ

combsimp

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

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

上述代码片段给出的输出等效于以下表达式：

x! / (x - 3)!

要简化上述组合表达式，我们使用 combsimp() 函数，如下所示：

>>> combsimp(expr)

上述代码片段给出的输出等效于以下表达式：

x(x - 2)(x - 1)

binomial(x, y) 是从 x 个不同项目集中选择 y 个项目的方法数。它也常写成 xCy。

>>> binomial(x,y)

上述代码片段给出的输出等效于以下表达式：

(x/y)

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

上述代码片段给出的输出等效于以下表达式：

(x + 1) / (y + 1)

logcombine

此函数采用对数并使用以下规则组合它们：

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

如果此函数的 force 参数设置为 True，则如果数量上不存在任何假设，则假定上述假设成立。

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

上述代码片段给出的输出等效于以下表达式：

log(x^a * y / 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²) + 1

>>> diff(expr,x)

上述代码片段给出的输出等效于以下表达式：

2x²cos(x²) + sin(x²)

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

上述代码片段给出的输出等效于以下表达式：

2xe^(x²)

要进行多次求导，请根据需要多次传递变量，或在变量后传递一个数字。

>>> 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²cos(x²) + sin(x²)

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

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

上述代码片段给出的输出等效于以下表达式：

d/dx(x*sin(x²) + 1)

>>> d.doit()

上述代码片段给出的输出等效于以下表达式：

2x²cos(x²) + sin(x²)

SymPy - 积分

SymPy 包包含 integrals 模块。它实现了计算表达式定积分和不定积分的方法。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)

上述代码片段给出的输出等效于以下表达式：

x³/3 + x²/2 + x

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

上述代码片段给出的输出等效于以下表达式：

-log(sin(x) - 1)/2 + log(sin(x) + 1)/2 - sin(x)

定积分示例如下：

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

上述代码片段给出的输出等效于以下表达式：

√π/2

您可以传递多个极限元组来执行多重积分。示例如下：

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

上述代码片段给出的输出等效于以下表达式：

π/4

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

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

上述代码片段给出的输出等效于以下表达式：

∫log(x)²dx

>>> expr.doit()

上述代码片段给出的输出等效于以下表达式：

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

积分变换

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

• 拉普拉斯变换 (laplace_transform)
• 傅里叶变换 (fourier_transform)
• 正弦变换 (sine_transform)
• 余弦变换 (cosine_transform)
• 汉克尔变换 (hankel_transform)

这些函数定义在 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 包含一个 matrices 模块，用于处理矩阵。它包含 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]

矩阵是可变对象。matrices 模块还提供 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() 方法。行列式是一个标量值，可以根据方阵的元素计算得出。

>>> 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 和 ones。单位矩阵是一个方阵，对角线上的元素设置为 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]

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

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

zeros 矩阵中的所有元素都初始化为 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** 模块中。

re

此函数返回表达式的实部：

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

以上代码片段的输出如下：

5

>>> re(I)

以上代码片段的输出为：

0

Im

此函数返回表达式的虚部：

>>> im(5+3*I)

以上代码片段的输出如下：

3

>>> im(I)

以上代码片段的输出如下：

1

sign

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

对于实数表达式，符号将为：

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

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

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

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

以上代码片段的输出如下：

(1, -1, 0)

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

以上代码片段的输出如下：

(-I, I)

Abs

此函数返回复数的绝对值。它定义为复平面上原点 (0,0) 与点 (a,b) 之间的距离。此函数是内置函数 abs() 的扩展，可以接受符号值。

>>> Abs(2+3*I)

以上代码片段的输出如下：

$\sqrt13$

conjugate

此函数返回复数的共轭。要找到复共轭，我们将改变虚部的符号。

>>> conjugate(4+7*I)

执行以上代码片段后，得到以下输出：

4 - 7i

三角函数

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

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

以上代码片段的输出如下：

(1, sqrt(2)/2, sqrt(3)/3)

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

以上代码片段的输出如下：

(pi/2, pi/4, pi/6)

整数函数

这是一组用于对整数执行各种运算的函数。

ceiling

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

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

以上代码片段的输出如下：

(4, 7, 3 + 4*I)

floor

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

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

以上代码片段的输出如下：

(3, 16, 6 - 6*I)

frac

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

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

以上代码片段的输出如下：

(0.990000000000000, 1/3, 0)

组合函数

组合数学是数学的一个分支，它关注有限或离散系统中的选择、排列和运算问题。

factorial

阶乘在组合数学中非常重要，它给出 n 个对象可以排列的方式的数量。它在符号上表示为 𝑥! 此函数是在非负整数上的阶乘函数的实现，负整数的阶乘是复无穷大。

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

以上代码片段的输出如下：

x!

>>> factorial(5)

以上代码片段的输出如下：

120

>>> factorial(-1)

以上代码片段的输出如下：

$\infty\backsim$

binomial

此函数表示从 n 个元素的集合中选择 k 个元素的方式的数量。

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

以上代码片段的输出如下：

(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]

fibonacci

斐波那契数列是由初始项 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$

add()

此方法在 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$

mul()

此方法执行两个四元数对象的乘法。

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

上述代码片段给出的输出等效于以下表达式：

$(-11) + 3i + 11j + 7k$

inverse()

此方法返回四元数对象的逆。

>>> q1.inverse()

上述代码片段给出的输出等效于以下表达式：

$\frac{1}{10} + (-\frac{1}{5})i + (-\frac{1}{10})j + (-\frac{1}{5})k$

pow()

此方法返回四元数对象的幂。

>>> q1.pow(2)

执行以上代码片段后得到以下输出：

$(-8) + 4i + 2j + 4k$

exp()

此方法计算四元数对象的指数，即 eq

>>> q=Quaternion(1,2,4,3) 
>>> q.exp()

执行以上代码片段后得到以下输出：

$e\cos(\sqrt29) + \frac{2\sqrt29e\sin(\sqrt29)}{29}i + \frac{4\sqrt29e\sin(\sqrt29)}{29}j + \frac{3\sqrt29e\sin}{29}k$

SymPy - 求解器

由于符号 = 和 == 在 Python 中定义为赋值运算符和相等运算符，因此它们不能用于制定符号方程。SymPy 提供 Eq() 函数来建立方程。

>>> from sympy import * 
>>> x,y=symbols('x y') 
>>> Eq(x,y)

上述代码片段给出的输出等效于以下表达式：

x = y

由于当且仅当 x-y=0 时 x=y 成立，因此上述方程可以写成：

>>> Eq(x-y,0)

上述代码片段给出的输出等效于以下表达式：

x − y = 0

SymPy 中的 solver 模块提供 solveset() 函数，其原型如下：

solveset(equation, variable, domain)

默认情况下，域为 S.Complexes。使用 solveset() 函数，可以如下求解代数方程：

>>> solveset(Eq(x**2-9,0), x)

获得以下输出：

{−3, 3}

>>> solveset(Eq(x**2-3*x, -2),x)

执行以上代码片段后得到以下输出：

{1,2}

solveset 的输出是解的 FiniteSet。如果没有解，则返回 EmptySet

>>> solveset(exp(x),x)

执行以上代码片段后得到以下输出：

$\varnothing$

线性方程

我们必须使用 linsolve() 函数来求解线性方程。

例如，方程如下：

x-y=4

x+y=1

>>> from sympy import * 
>>> x,y=symbols('x y') 
>>> linsolve([Eq(x-y,4),Eq( x + y ,1) ], (x, y))

执行以上代码片段后得到以下输出：

$\lbrace(\frac{5}{2},-\frac{3}{2})\rbrace$

linsolve() 函数也可以求解以矩阵形式表示的线性方程。

>>> a,b=symbols('a b') 
>>> a=Matrix([[1,-1],[1,1]]) 
>>> b=Matrix([4,1]) 
>>> linsolve([a,b], (x,y))

如果执行以上代码片段，我们将得到以下输出：

$\lbrace(\frac{5}{2},-\frac{3}{2})\rbrace$

非线性方程

为此，我们使用 nonlinsolve() 函数。此示例的方程：

a²+a=0 a-b=0

>>> a,b=symbols('a b') 
>>> nonlinsolve([a**2 + a, a - b], [a, b])

如果执行以上代码片段，我们将得到以下输出：

$\lbrace(-1, -1),(0,0)\rbrace$

微分方程

首先，通过将 cls=Function 传递给 symbols 函数来创建一个未定义的函数。要求解微分方程，请使用 dsolve。

>>> x=Symbol('x') 
>>> f=symbols('f', cls=Function) 
>>> f(x)

执行以上代码片段后得到以下输出：

f(x)

这里 f(x) 是一个未计算的函数。其导数如下：

>>> f(x).diff(x)

上述代码片段给出的输出等效于以下表达式：

$\frac{d}{dx}f(x)$

我们首先创建与以下微分方程对应的 Eq 对象

>>> eqn=Eq(f(x).diff(x)-f(x), sin(x)) 
>>> eqn

上述代码片段给出的输出等效于以下表达式：

$-f(x) + \frac{d}{dx}f(x)= \sin(x)$

>>> dsolve(eqn, f(x))

上述代码片段给出的输出等效于以下表达式：

$f(x)=(c^1-\frac{e^-x\sin(x)}{2}-\frac{e^-x\cos(x)}{2})e^x$

SymPy - 绘图

SymPy 使用 Matplotlib 库作为后端来渲染数学函数的二维和三维图。确保当前 Python 安装中可以使用 Matplotlib。如果不是，请使用以下命令安装：

pip install matplotlib

绘图支持定义在 sympy.plotting 模块中。绘图模块中存在以下函数：

• **plot** - 二维线图

• **plot3d** - 三维线图

• **plot_parametric** - 二维参数图

• **plot3d_parametric** - 三维参数图

plot() 函数返回 Plot 类的实例。一个绘图图形可以有一个或多个 SymPy 表达式。虽然它能够使用 Matplotlib 作为后端，但也可以使用其他后端，例如 texplot、pyglet 或 Google charts API。

plot(expr, range, kwargs)

其中 expr 是任何有效的 symPy 表达式。如果没有提及，则范围使用默认值 (-10, 10)。

以下示例绘制范围 (-10,10) 中每个值的 x2 值：

>>> from sympy.plotting import plot 
>>> from sympy import * 
>>> x=Symbol('x') 
>>> plot(x**2, line_color='red')

要绘制同一范围内的多个图形，请在范围元组之前给出多个表达式。

>>> plot( sin(x),cos(x), (x, -pi, pi))

您也可以为每个表达式指定单独的范围。

plot((expr1, range1), (expr2, range2))

下图在不同范围内绘制了 sin(x) 和 cos(x)。

>>> plot( (sin(x),(x, -2*pi, 2*pi)),(cos(x), (x, -pi, pi)))

可以在 plot() 函数中指定以下可选关键字参数。

• line_color − 指定绘图线的颜色。

• title − 要显示为标题的字符串

• xlabel − 要显示为 X 轴标签的字符串

• ylabel − 要显示为 y 轴标签的字符串

>>> plot( (sin(x),(x, -2*pi, 2*pi)),(cos(x), (x, -pi, pi)), line_color='red', title='SymPy plot example')

plot3d() 函数渲染三维图形。

plot3d(expr, xrange, yrange, kwargs)

以下示例绘制了一个 3D 表面图：

>>> from sympy.plotting import plot3d 
>>> x,y=symbols('x y') 
>>> plot3d(x*y, (x, -10,10), (y, -10,10))

与二维图形一样，三维图形也可以有多个图形，每个图形都有不同的范围。

>>> plot3d(x*y, x/y, (x, -5, 5), (y, -5, 5))

plot3d_parametric_line() 函数渲染三维参数线图。

>>> from sympy.plotting import plot3d_parametric_line 
>>> plot3d_parametric_line(cos(x), sin(x), x, (x, -5, 5))

要绘制参数曲面图，请使用 plot3d_parametric_surface() 函数。

plot3d_parametric_surface(xexpr, yexpr, zexpr, rangex, rangey, kwargs)

>>> from sympy.plotting import plot3d_parametric_surface 
>>> plot3d_parametric_surface(cos(x+y), sin(x-y), x-y, (x, -5, 5), (y, -5, 5))

SymPy - 实体

SymPy 中的 geometry 模块允许创建二维实体，例如线、圆等。然后，我们可以获得有关它们的的信息，例如检查共线性或查找交点。

点

Point 类表示欧几里得空间中的一个点。以下示例检查点的共线性：

>>> from sympy.geometry import Point 
>>> from sympy import * 
>>> x=Point(0,0) 
>>> y=Point(2,2) 
>>> z=Point(4,4) 
>>> Point.is_collinear(x,y,z)

输出

True

>>> a=Point(2,3) 
>>> Point.is_collinear(x,y,a)

输出

False

Point 类的 distance() 方法计算两点之间的距离

>>> x.distance(y)

输出

$2\sqrt2$

距离也可以用符号表示。

线

线实体是从两个 Point 对象获得的。如果两条线相交，则 intersection() 方法返回交点。

>>> from sympy.geometry import Point, Line 
>>> p1, p2=Point(0,5), Point(5,0) 
>>> l1=Line(p1,p2)
>>> l2=Line(Point(0,0), Point(5,5)) 
>>> l1.intersection(l2)

输出

[Point2D(5/2, 5/2)]

>>> l1.intersection(Line(Point(0,0), Point(2,2)))

输出

[Point2D(5/2, 5/2)]

>>> x,y=symbols('x y') 
>>> p=Point(x,y) 
>>> p.distance(Point(0,0))

输出

$\sqrt{x^2 + y^2}$

三角形

此函数根据三个点对象构建三角形实体。

Triangle(a,b,c)

>>> t=Triangle(Point(0,0),Point(0,5), Point(5,0)) 
>>> t.area

输出

$-\frac{25}{2}$

椭圆

椭圆几何实体是通过传递对应于中心和两个数字（每个数字分别对应水平和垂直半径）的 Point 对象来构造的。

ellipse(center, hradius, vradius)

>>> from sympy.geometry import Ellipse, Line 
>>> e=Ellipse(Point(0,0),8,3) 
>>> e.area

输出

$24\pi$

可以使用偏心率参数间接提供 vradius。

>>> e1=Ellipse(Point(2,2), hradius=5, eccentricity=Rational(3,4)) 
>>> e1.vradius

输出

$\frac{5\sqrt7}{4}$

椭圆的远拱点是焦点和轮廓之间最大的距离。

>>> e1.apoapsis

输出

$\frac{35}{4}$

以下语句计算椭圆的周长：

>>> e1.circumference

输出

$20E(\frac{9}{16})$

椭圆的equation方法返回椭圆的方程。

>>> e1.equation(x,y)

输出

$(\frac{x}{5}-\frac{2}{5})^2 + \frac{16(y-2)^2}{175} - 1$

SymPy - 集合

在数学中，集合是不同对象的明确定义的集合，这些对象可以是数字、人、字母表中的字母，甚至是其他集合。集合也是 Python 中的内置类型之一。SymPy 提供了 sets 模块。它包含不同类型集合的定义，并具有执行集合运算（例如交集、并集等）的功能。

Set 是 SymPy 中任何其他类型集合的基类。请注意，它与 Python 的内置集合数据类型不同。Interval 类表示实数区间，其边界属性返回一个FiniteSet对象。

>>> from sympy import Interval 
>>> s=Interval(1,10).boundary 
>>> type(s)

sympy.sets.sets.FiniteSet

FiniteSet 是离散数字的集合。可以从任何序列对象（例如列表或字符串）获得它。

>>> from sympy import FiniteSet 
>>> FiniteSet(range(5))

输出

$\lbrace\lbrace0,1,...,4\rbrace\rbrace$

>>> numbers=[1,3,5,2,8] 
>>> FiniteSet(*numbers)

输出

$\lbrace1,2,3,5,8\rbrace$

>>> s="HelloWorld" 
>>> FiniteSet(*s)

输出

{H,W,d,e,l,o,r}

请注意，与内置集合一样，SymPy 的 Set 也是不同对象的集合。

ConditionSet 是满足给定条件的元素的集合

>>> from sympy import ConditionSet, Eq, Symbol 
>>> x=Symbol('x') 
>>> s=ConditionSet(x, Eq(x**2-2*x,0), Interval(1,10)) >>> s

输出

$\lbrace x\mid x\in[1,10]∧x^2 - 2x =0\rbrace$

Union 是一个复合集合。它包含两个集合中的所有元素。请注意，在两者中都找到的元素在 Union 中只会出现一次。

>>> from sympy import Union 
>>> l1=[3,1,5,7] 
>>> l2=[9,7,2,1] 
>>> a=FiniteSet(*l1) 
>>> b=FiniteSet(*l2) 
>>> Union(a,b)

另一方面，Intersection 只包含同时存在于两者的元素。

>>> from sympy import Intersection 
>>> Intersection(a,b)

ProductSet 对象表示两个集合中元素的笛卡尔积。

>>> from sympy import ProductSet 
>>> l1=[1,2] 
>>> l2=[2,3] 
>>> a=FiniteSet(*l1) 
>>> b=FiniteSet(*l2) 
>>> set(ProductSet(a,b))

Complement(a,b) 保留集合 a 中的元素，但不包括与集合 b 共有的元素。

>>> from sympy import Complement 
>>> l1=[3,1,5,7] 
>>> l2=[9,7,2,1] 
>>> a=FiniteSet(*l1) 
>>> b=FiniteSet(*l2) 
>>> Complement(a,b), Complement(b,a)

SymmetricDifference 集合仅包含两个集合中不共有的元素。

>>> from sympy import SymmetricDifference 
>>> l1=[3,1,5,7] 
>>> l2=[9,7,2,1] 
>>> a=FiniteSet(*l1) 
>>> b=FiniteSet(*l2) 
>>> SymmetricDifference(a,b)

输出

{2,3,5,9}

SymPy - 打印

SymPy 中有几个可用的打印机。以下是部分列表：

• str
• srepr
• ASCII 美化打印机
• Unicode 美化打印机
• LaTeX
• MathML
• Dot

SymPy 对象也可以作为各种语言（例如 C、Fortran、Javascript、Theano 和 Python）代码的输出发送。

SymPy 使用 Unicode 字符以美化打印的形式呈现输出。如果您使用 Python 控制台执行 SymPy 会话，则最佳美化打印环境是通过调用 init_session() 函数激活的。

>>> from sympy import init_session 
>>> init_session()

用于 SymPy 1.5.1 的 IPython 控制台（Python 3.7.4-64 位）（地面类型：python）。

执行了这些命令：

>>> from __future__ import division
>>> from sympy import *
>>> x, y, z, t = symbols('x y z t')
>>> k, m, n = symbols('k m n', integer=True)
>>> f, g, h = symbols('f g h', cls=Function)
>>> init_printing()

文档可在 https://docs.sympy.cn/1.5.1/. 找到。

>>> Integral(sqrt(1/x),x)

$\int \sqrt\frac{1}{x} dx$

如果未安装 LATEX，但已安装 Matplotlib，它将使用 Matplotlib 渲染引擎。如果未安装 Matplotlib，它将使用 Unicode 美化打印机。但是，Jupyter notebook 使用 MathJax 渲染 LATEX。

在不支持 Unicode 的终端中，将使用 ASCII 美化打印机。

要使用 ASCII 打印机，请将 use_unicode 属性设置为 False，然后使用 pprint() 函数。

>>> pprint(Integral(sqrt(1/x),x),use_unicode=False)

Unicode 美化打印机也可以从 pprint() 和 pretty() 访问。如果终端支持 Unicode，则会自动使用它。如果 pprint() 无法检测到终端支持 unicode，则可以传递 use_unicode=True 以强制其使用 Unicode。

要获得表达式的 LATEX 形式，请使用 latex() 函数。

>>> print(latex(Integral(sqrt(1/x),x)))

\int \sqrt{\frac{1}{x}}\, dx

您也可以使用 mathml 打印机。为此，请导入 print_mathml 函数。字符串版本由 mathml() 函数获得。

>>> from sympy.printing.mathml import print_mathml 
>>> print_mathml(Integral(sqrt(1/x),x))

<apply>

<int/>

<bvar>

<ci>x</ci>

</bvar>

<apply>

<root/>

<apply>

<power/>

<ci>x</ci>

<cn>-1</cn>

</apply>

</apply>

</apply>

>>>mathml(Integral(sqrt(1/x),x))

'<apply><int/><bvar><ci>x</ci></bvar><apply><root/><apply><power/><ci>x</ci><cn>-1</cn></apply></apply></apply>'