Sympy 简明教程

SymPy - Quick Guide

SymPy - Introduction

SymPy 是执行符号计算的 Python 库。它是一个 computer algebra system (CAS),可以用作独立应用程序或作为其他应用程序的库。它的实时会话也可在 https://live.sympy.org/ 上获取。因为它是一个纯 Python 库,所以可以用交互模式和编程应用程序使用。SymPy 已成为科学 Python 生态系统中流行的符号库。

SymPy 具备广泛的功能,适用于基本符号算术、微积分、代数、离散数学、量子物理学等领域。SymPy 可以以多种格式(包括 LaTeX、MathML 等)设置结果格式。SymPy 按照新 BSD 许可证分发。由 Ondřej ČertíkAaron Meurer 领导的开发人员团队于 2007 年发布了 SymPy 的第一个版本。它的当前版本是 1.5.1。

SymPy 的一些应用领域有 -

  1. Polynomials

  2. Calculus

  3. Discrete maths

  4. Matrices

  5. Geometry

  6. Plotting

  7. Physics

  8. Statistics

  9. Combinatorics

SymPy - Installation

SymPy 有一个重要的先决条件库,名称为 mpmath 。这个 Python 库用于任意精度的实数和复数浮点运算。但是,在按以下方式安装 SymPy 时,Python 的软件包安装程序 PIP 会自动安装它 -

pip install sympy

其他 Python 分发包(如 Anaconda、Enthought Canopy 等)可能已将 SymPy 内置其中。要验证,可以在 Python 提示符中键入以下内容 -

>>> import sympy
>>> sympy.__version__

然后你将获得如下 SymPy 当前版本输出 -

'1.5.1'

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

SymPy - Symbolic Computation

符号计算指的是用于操纵数学表达式和其他数学对象的算法的开发。符号计算将数学与计算机科学结合起来,使用数学符号来求解数学表达式。计算机代数系统(CAS),如 SymPy,使用传统手工方法中使用的相同符号精确求解(非近似)代数表达式。举个例子,我们可以像下面给出的那样,使用 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$

可以使用传统的符号来表示非完全平方数的平方根,如下所示

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

上述代码段的输出如下:

$\sqrt7$

符号计算系统(如 SymPy)能够以符号形式执行各种计算(如导数、积分和极限,求解方程,使用矩阵)。SymPy 包含不同的模块,这些模块支持绘图、打印(如 LATEX)、物理、统计、组合、数论、几何、逻辑等。

SymPy - Numbers

SymPy 包中的核心模块包含表示原子数的数字类。该类有两个子类: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}$

如果传递两个数字参数,也可以获得有理数对象。分子和分母部分作为属性提供。

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

上述代码段的输出如下:

3/5

numerator:3, denominator: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 - Symbols

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, EQ 是预定义符号。此外,在 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 - Substitution

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

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

上面的代码片段给出的输出等同于以下表达式 −

$\sin2(x)+\cos2(x)$

>>> expr.subs(x,a)

上面的代码片段给出的输出等同于以下表达式 −

$\sin2(a)+\cos2(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() function

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

此函数会计算给定的数值表达式,其浮点精度最高为 100 位。此函数还使用 subs 参数获取符号的数值字典对象。考虑以下表达式

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

上面的代码片段给出的输出等同于以下表达式 −

$\Pi{r^2}$

要使用 evalf() 函数求值以上表达式,请用 5 替换 r

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

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 数组。对于 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

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

BooleanTrue function

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

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

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

(True, True)

BooleanFalse function

类似地,此函数等效于 Python 中的布尔 False,可以通过 S.false 访问。

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

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

(False, False)

And function

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

此函数对两个布尔参数求值,如果其中任何一个为 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 Function

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

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

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

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

此函数返回等价关系。当且仅当 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)

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

(False, True)

ITE function

此函数充当编程语言中的 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 - Querying

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

sympy.assumptions.ask(property)

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

algebraic(x)

为了成为代数数,一个数必须是有理系数的非零多项式方程的根。√2 是代数数,因为 √2 是 x2 − 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 属于偶数集的真值。

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

Sympy 有强大的数学表达式简化能力。SymPy 中有许多函数可执行各种类型的化简。有一个称为 simplify() 的通用函数,它尝试到达表达式的最简单形式。

simplify

此函数在 sympy.simplify 模块中定义。simplify() 尝试应用智能启发式来使输入表达式“更简单”。以下代码显示了表达式 $sin 2(x)+cos 2(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^2 + 2ab + b^2$

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

上面的代码片段给出的输出等同于以下表达式 −

$a^2 - b^2$

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

collect

此函数收集表达式中的加法项,根据含有有理指数的表达式列表分项。

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

上面的代码片段给出的输出等同于以下表达式 −

$Y3+Y2(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

上面的代码片段给出的输出等同于以下表达式 −

$\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)}$

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^y x^z y^z$

>>> powsimp(expr)

上面的代码片段给出的输出等同于以下表达式 −

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

可以通过改变 combine=’base’ 或 combine=’exp’ 来使 powsimp() 仅合并底数或仅合并指数。默认情况下,combine=’all’,它同时执行这两个操作。如果 force 为 True,则会在不检查假设的情况下合并底数。

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

上面的代码片段给出的输出等同于以下表达式 −

$xy(xy)z$

combsimp

涉及阶乘和二项式的组合表达式可使用 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}$

logcombine

此函数取对数并将它们使用以下规则进行合并:

  1. 如果同时为正,则 log(x) + log(y) == log(x*y)

  2. 如果 x 为正而且 a 为实数,则 a*log(x) == log(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\frac{x^a y}{z}$

SymPy - Derivative

函数的导数是指它相对于其一个变量的瞬时变化率。这相当于找到该函数在某一点的切线斜率。我们能够使用 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)

上面的代码片段给出的输出等同于以下表达式 −

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

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

上面的代码片段给出的输出等同于以下表达式 −

2xex2

若要获取多个导数,按照需要求导的次数传递变量,或在变量后传递一个数字。

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

上面的代码片段给出的输出等同于以下表达式 −

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

使用 Derivative 类可以创建一个未求值的导数。它的语法与 diff() 函数相同。若要求一个未求值的导数,请使用 doit 方法。

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

上面的代码片段给出的输出等同于以下表达式 −

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

>>> d.doit()

上面的代码片段给出的输出等同于以下表达式 −

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

SymPy - Integration

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)

上面的代码片段给出的输出等同于以下表达式 −

$\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 对象创建未计算的积分,而 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$

Integral Transforms

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

  1. laplace_transform

  2. fourier_transform

  3. sine_transform

  4. cosine_transform

  5. hankel_transform

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

Example 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{\pi2k^2}$

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

在数学中,矩阵是二维数字、符号或表达式的数组。矩阵操作的理论涉及对矩阵目标执行算术操作,但要遵循特定规则。

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

SymPy 包具有处理矩阵的 matrices 模块。他包含 Matrix 类,其对象表示一个矩阵。

Note: If you want to execute all the snippets in this chapter individually, you need to import the matrix module as shown below −

>>> from sympy.matrices import Matrix

Example

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

可以使用大小合适的 List 对象创建矩阵。也可以通过按指定行数和列数分配列表项来获取矩阵。

>>> 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 类来获取不可变矩阵。

Basic manipulation

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]

Arithmetic Operations

通常的操作符 + 、 - 和 * 被定义为执行加法、减法和乘法运算。

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

Matrix Constructors

SymPy 提供了许多特殊类型的矩阵类。例如,单位矩阵、由所有零和一组成的矩阵等。这些类分别命名为 eye、zeros 和 ones。单位矩阵是一个方阵,对角线上的元素设置为 1,其余元素均为 0。

Example

from sympy.matrices import eye eye(3)

Output

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

Sympy 包具有 Function 类,该类在 sympy.core.function 模块中定义。它是一个基类,适用于所有应用的数学函数,也是未定义函数类的构造函数。

以下类别的函数从 Function 类继承 −

  1. Functions for complex number

  2. Trigonometric functions

  3. Functions for integer number

  4. Combinatorial functions

  5. Other miscellaneous functions

Functions for complex number

这组函数在 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. 如果表达式为正,则为 1

  2. 如果表达式等于零,则为 0

  3. 如果表达式为负,则为 -1

如果表达式为虚部,返回的标志为 −

  1. 如果 im(expression) 为正,则为 I

  2. 如果 im(expression) 为负,则为 -I

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

Trigonometric functions

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)

Functions on Integer Number

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

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)

Combinatorial functions

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

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)

以上代码片段的输出如下所示 −

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

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

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]

Miscellaneous Functions

以下是一些常用函数的列表 −

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

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

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

q=a+bi+cj+dk

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

sympy.algebras.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()

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

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

由于符号 = 和 == 在 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 模块提供了 soveset() 函数,其原型如下 −

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 的输出是有限集的解。如果没有解,则返回空集

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

执行上面的代码片段后获得以下输出 −

$\varnothing$

Linear equation

我们必须使用 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$

Non-linear equation

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

a2+a=0 a-b=0

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

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

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

differential equation

首先,通过将 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)=(c1-\frac{e-xsin(x)}{2}-\frac{e-xcos(x)}{2})ex$

SymPy - Plotting

SymPy 使用 Matplotlib 库作为后端来渲染数学函数的 2D 和 3D 图。确保在当前 Python 安装中可以使用 Matplotlib。如果没有,请使用以下命令安装相同的命令 -

pip install matplotlib

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

  1. plot - 2D 线图

  2. plot3d - 3D 线图

  3. plot_parametric - 2D 参数图

  4. plot3d_parametric - 3D 参数图

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

plot(expr, range, kwargs)

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

以下示例绘制了 range(-10,10) 中每个值 x2 的值 -

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

要为相同范围绘制多张图,请在范围元组之前给出多个表达式。

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

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

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

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

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

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

  1. line_color − 指定绘图线条的颜色。

  2. title − 作为标题显示的字符串

  3. xlabel − 作为 X 轴标签显示的字符串

  4. ylabel − 作为 y 轴标签显示的字符串

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

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

plot3d(expr, xrange, yrange, kwargs)

以下示例绘制一个三维曲面图形 −

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

与 2D 图形类似,三维图形也可以有多个不同范围的图形。

>>> plot3d(x*y, x/y, (x, -5, 5), (y, -5, 5))
3 dimensional parametric line plot

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

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

要绘制参数曲面图形,请使用 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))
plot 3d parametric surface function

SymPy - Entities

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

Point

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)

Output

True

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

Output

False

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

>>> x.distance(y)

Output

$2\sqrt2$

距离也可以用符号来表示。

Line

线实体是由两个点对象获得的。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)

Output

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

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

Output

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

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

Output

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

Triangle

这个函数用三个点对象构建一个三角形实体。

Triangle(a,b,c)

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

Output

$-\frac{25}{2}$

Ellipse

一个椭圆几何实体是由一个对应于中心点的点对象和两个数字(分别代表水平和垂直半径)构成的。

ellipse(center, hradius, vradius)

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

Output

$24\pi$

可以使用偏心参数间接给出垂直半径。

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

Output

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

椭圆的 apoapsis 是焦点与轮廓线之间的最长距离。

>>> e1.apoapsis

Output

$\frac{35}{4}$

下述语句计算椭圆的圆周率 -

>>> e1.circumference

Output

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

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

>>> e1.equation(x,y)

Output

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

SymPy - Sets

在数学中,一个集合是有序离散对象 مجموعة منظمة من كائنات منفصلة مرتبة جيدًا 的集合,这些对象可能是数字、人、字母或甚至是其他集合。集合也是 Python 中的内置类型之一。SymPy 提供集合模块。它包含不同类型的集合的定义,并具有执行交集、并集等集合运算的功能。

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

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

sympy.sets.sets.FiniteSet

有限集合是离散数字的集合。它可以从列表或字符串等任何序列对象中获取。

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

Output

$\lbrace\lbrace0,1,…​,4\rbrace\rbrace$

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

Output

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

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

Output

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

请注意,在内置集合中,SymPy 的集合也是离散对象的集合。

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

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

Output

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

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)

Output

{2,3,5,9}

SymPy - Printing

SymPy 中提供有若干打印机。以下是部分列表 -

  1. str

  2. srepr

  3. ASCII pretty printer

  4. Unicode pretty printer

  5. LaTeX

  6. MathML

  7. 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.org/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 pretty printer

要使用 ASCII 打印机,请使用将 use_unicode 属性设置为 False 的 pprint() 函数

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

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