Sympy 简明教程
SymPy - Introduction
SymPy 是执行符号计算的 Python 库。它是一个 computer algebra system (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 的一些应用领域有 -
-
Polynomials
-
Calculus
-
Discrete maths
-
Matrices
-
Geometry
-
Plotting
-
Physics
-
Statistics
-
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, 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 - 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
上面的代码段给出了以下输出:
BooleanFalse function
类似地,此函数等效于 Python 中的布尔 False,可以通过 S.false 访问。
>>> from sympy import *
>>> x=sympify(false)
>>> x, S.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
上面的代码段给出了以下输出:
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
上面的代码段给出了以下输出:
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)
上面的代码段给出了以下输出:
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)
上面的代码段给出了以下输出:
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)
上面的代码段给出了以下输出:
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)
上面的代码段给出了以下输出:
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)
上面的代码段给出了以下输出:
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
此函数取对数并将它们使用以下规则进行合并:
-
如果同时为正,则 log(x) + log(y) == log(x*y)
-
如果 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 支持各种类型的积分变换,如下所示 -
-
laplace_transform
-
fourier_transform
-
sine_transform
-
cosine_transform
-
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 类继承 −
-
Functions for complex number
-
Trigonometric functions
-
Functions for integer number
-
Combinatorial functions
-
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
-
如果表达式等于零,则为 0
-
如果表达式为负,则为 -1
如果表达式为虚部,返回的标志为 −
-
如果 im(expression) 为正,则为 I
-
如果 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$
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 模块中定义。绘图模块中存在以下函数 -
-
plot - 2D 线图
-
plot3d - 3D 线图
-
plot_parametric - 2D 参数图
-
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')
要为相同范围绘制多张图,请在范围元组之前给出多个表达式。
>>> 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)
以下示例绘制一个三维曲面图形 −
>>> from sympy.plotting import plot3d
>>> x,y=symbols('x y')
>>> plot3d(x*y, (x, -10,10), (y, -10,10))
与 2D 图形类似,三维图形也可以有多个不同范围的图形。
>>> 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 - 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 中提供有若干打印机。以下是部分列表 -
-
str
-
srepr
-
ASCII pretty printer
-
Unicode pretty printer
-
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.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 打印机,请使用将 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>'