原文： http://zetcode.com/python/sympy/

SymPy 教程展示了如何使用 SymPy 模块在 Python 中进行符号计算。 这是对 SymPy 的简要介绍。

计算机代数系统（CAS）是一种数学软件，能够以类似于数学家和科学家的传统手动计算方式来处理数学表达式。

符号计算象征性地处理数学对象的计算。 数学对象是准确而非近似地表示的，具有未求值变量的数学表达式以符号形式保留。

SymPy

SymPy 是用于符号数学的 Python 库。 它旨在成为功能齐全的计算机代数系统。 SymPy 包括从基本符号算术到微积分，代数，离散数学和量子物理学的功能。 它可以在 LaTeX 中显示结果。

  1. $ pip install sympy

SymPy 是使用pip install sympy命令安装的。

Rational值

SymPy 具有用于处理有理数的Rational。 有理数是可以表示为两个整数（分子p和非零分母q）的商或分数p / q的任何数字。

rational_values.py

  1. #!/usr/bin/env python
  3. from sympy import Rational
  5. r1 = Rational(1/10)
  6. r2 = Rational(1/10)
  7. r3 = Rational(1/10)
  9. val = (r1 + r2 + r3) * 3
  10. print(val.evalf())
  12. val2 = (1/10 + 1/10 + 1/10) * 3
  13. print(val2)

该示例使用有理数。

  1. val = (r1 + r2 + r3) * 3
  2. print(val.evalf())

该表达形式为符号形式。 我们使用evalf()方法对其进行求值。

  1. $ rational_values.py
  2. 0.900000000000000
  3. 0.9000000000000001

注意，当不使用有理数时，输出中会有一个小错误。

SymPy pprint

pprint()用于在控制台上精美打印输出。 LaTeX 可以达到最佳效果，例如在 Jupyter 笔记本中。

prettify.py

  1. #!/usr/bin/env python
  3. from sympy import pprint, Symbol, exp, sqrt
  4. from sympy import init_printing
  6. init_printing(use_unicode=True)
  8. x = Symbol('x')
  10. a = sqrt(2)
  11. pprint(a)
  12. print(a)
  14. print("------------------------")
  16. c = (exp(x) ** 2)/2
  17. pprint(c)
  18. print(c)

程序会美化输出。

  1. init_printing(use_unicode=True)

对于某些字符，我们需要启用 unicode 支持。

  1. $ prettify.py
  2. √2
  3. sqrt(2)
  4. ------------------------
  5.     2⋅x
  6. ℯ
  7. ────
  8.     2
  9. exp(2*x)/2

这是输出。 请注意，使用 Jupyter 笔记本会提供更好的输出。

平方根

平方根是一个数字，乘以它会产生指定的数量。

square_root.py

  1. #!/usr/bin/env python
  3. from sympy import sqrt, pprint, Mul
  5. x = sqrt(2)
  6. y = sqrt(2)
  8. pprint(Mul(x,  y, evaluate=False)) 
  9. print('equals to ')
  10. print(x * y)

程序输出一个包含平方根的表达式。

  1. pprint(Mul(x,  y, evaluate=False))

我们使用evaluate属性推迟对乘法表达式的求值。

  1. $ square_root.py
  2. √2⋅√2
  3. equals to
  4. 2

这是输出。

SymPy 符号

符号计算适用于符号，以后可以对其进行求值。 使用符号之前，必须在 SymPy 中定义符号。

def_sym.py

  1. #!/usr/bin/env python
  3. # ways to define symbols
  5. from sympy import Symbol, symbols
  6. from sympy.abc import x, y
  8. expr = 2*x + 5*y
  9. print(expr)
  11. a = Symbol('a')
  12. b = Symbol('b')
  14. expr2 = a*b + a - b
  15. print(expr2)
  17. i, j = symbols('i j')
  18. expr3 = 2*i*j + i*j
  19. print(expr3)

该程序显示了三种在 SymPy 中定义符号的方法。

  1. from sympy.abc import x, y

可以从sympy.abc模块导入符号。 它将所有拉丁字母和希腊字母导出为符号，因此我们可以方便地使用它们。

  1. a = Symbol('a')
  2. b = Symbol('b')

可以用Symbol定义

  1. i, j = symbols('i j')

可以使用symbols()方法定义多个符号。

SymPy 规范表达形式

SymPy 会自动将表达式转换为规范形式。 SymPy 仅执行廉价操作； 因此，表达式可能无法求值为最简单的形式。

canonical_form.py

  1. #!/usr/bin/env python
  3. from sympy.abc import a, b
  5. expr = b*a + -4*a + b + a*b + 4*a + (a + b)*3
  7. print(expr)

我们有一个带有符号a和b的表达式。 该表达可以容易地简化。

  1. $ canonical_form.py
  2. 2*a*b + 3*a + 4*b

这是输出。

SymPy 扩展代数表达式

使用expand()，我们可以扩展代数表达式； 即该方法尝试消除幂和乘法。

expand.py

  1. #!/usr/bin/env python
  3. from sympy import expand, pprint
  4. from sympy.abc import x
  6. expr = (x + 1) ** 2
  8. pprint(expr)
  10. print('-----------------------')
  11. print('-----------------------')
  13. expr = expand(expr)
  14. pprint(expr)

该程序扩展了一个简单的表达式。

  1. $ expand.py
  2.        2
  3. (x + 1)
  4. -----------------------
  5. -----------------------
  6.  2
  7. x  + 2⋅x + 1

这是输出。

SymPy 简化表达式

可以使用simplify()将表达式更改为更简单的形式。

simplify.py

  1. #!/usr/bin/env python
  3. from sympy import sin, cos, simplify, pprint
  4. from sympy.abc import x
  6. expr = sin(x) / cos(x)
  8. pprint(expr)
  10. print('-----------------------')
  12. expr = simplify(expr)
  13. pprint(expr)

例如将sin(x)/sin(y)表达式简化为tan(x)。

  1. $ simplify.py
  2. sin(x)
  3. ──────
  4. cos(x)
  5. -----------------------
  6. tan(x)

这是输出。

SymPy 比较表达式

SymPy 表达式与equals()而不是==运算符进行比较。

expr_equality.py

  1. #!/usr/bin/env python
  3. from sympy import pprint, Symbol, sin, cos
  5. x = Symbol('x')
  7. a = cos(x)**2 - sin(x)**2
  8. b = cos(2*x)
  10. print(a.equals(b))
  12. # we cannot use == operator
  13. print(a == b)

该程序比较两个表达式。

  1. print(a.equals(b))

我们用equals()比较两个表达式。 在应用该方法之前，SymPy 尝试简化表达式。

  1. $ expr_equality.py
  2. True
  3. False

这是输出。

SymPy 求值表达式

可以通过替换符号来求值表达式。

evaluating.py

  1. #!/usr/bin/env python
  3. from sympy import pi
  5. print(pi.evalf(30))

该示例将pi值求值为 30 个位。

  1. $ evaluating.py
  2. 3.14159265358979323846264338328

这是输出。

evaluating2.py

  1. #!/usr/bin/env python
  3. from sympy.abc import a, b
  4. from sympy import pprint
  6. expr = b*a + -4*a + b + a*b + 4*a + (a + b)*3
  8. print(expr.subs([(a, 3), (b, 2)]))

本示例通过用数字替换a和b符号来求值表达式。

  1. $ evaluating.py
  2. 3.14159265358979323846264338328

这是输出。

SymPy 求解方程

用solve()或solveset()求解方程。

solving.py

  1. #!/usr/bin/env python
  3. from sympy import Symbol, solve
  5. x = Symbol('x')
  7. sol = solve(x**2 - x, x)
  9. print(sol)

该示例使用solve()解决了一个简单方程。

  1. sol = solve(x**2 - x, x)

solve()的第一个参数是公式。 该公式以适合 SymPy 的特定形式编写； 即x**2 - x代替x**2 = x。 第二个参数是我们需要解决的符号。

  1. $ solving.py
  2. [0, 1]

该方程式有两个解：0 和 1。

或者，我们可以将Eq用于公式。

solving2.py

  1. #!/usr/bin/env python
  3. from sympy import pprint, Symbol, Eq, solve
  5. x = Symbol('x')
  7. eq1 = Eq(x + 1, 4)
  8. pprint(eq1)
  10. sol = solve(eq1, x)
  11. print(sol)

该示例解决了一个简单的x + 1 = 4方程。

  1. $ solving2.py
  2. x + 1 = 4
  3. [3]

这是输出。

solving3.py

  1. #!/usr/bin/env python
  3. from sympy.solvers import solveset
  4. from sympy import Symbol, Interval, pprint
  6. x = Symbol('x')
  8. sol = solveset(x**2 - 1, x, Interval(0, 100))
  9. print(sol)

使用solveset()，我们找到了给定间隔的解决方案。

  1. $ solving3.py
  2. {1}

这是输出。

SymPy 序列

序列是其中允许重复的对象的枚举集合。 序列可以是有限的或无限的。 元素的数量称为序列的长度。 与集合不同，同一元素可以在序列中的不同位置出现多次。 元素的顺序很重要。

sequence.py

  1. #!/usr/bin/env python
  3. from sympy import summation, sequence, pprint
  4. from sympy.abc import x
  6. s = sequence(x, (x, 1, 10))
  7. print(s)
  8. pprint(s)
  9. print(list(s))
  11. print(s.length)
  13. print(summation(s.formula, (x, s.start, s.stop)))
  14. # print(sum(list(s)))

本示例创建一个由数字 1、2，…，10 组成的序列。 我们计算这些数字的总和。

  1. $ sequence.py
  2. SeqFormula(x, (x, 1, 10))
  3. [1, 2, 3, 4, …]
  4. [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  5. 10
  6. 55

这是输出。

SymPy 极限

极限是函数（或序列）“接近”作为输入（或索引）“接近”某个值的值。

limit.py

  1. #!/usr/bin/env python
  3. from sympy import sin, limit, oo
  4. from sympy.abc import x
  6. l1 = limit(1/x, x, oo)
  7. print(l1)
  9. l2 = limit(1/x, x, 0)
  10. print(l2)

在示例中，我们具有1/x函数。 它具有左侧和右侧限制。

  1. from sympy import sin, limit, sqrt, oo

oo表示无穷大。

  1. l1 = limit(1/x, x, oo)
  2. print(l1)

我们计算1/x的极限，其中x接近正无穷大。

  1. $ limit.py
  2. 0
  3. oo

这是输出。

SymPy 矩阵

在 SymPy 中，我们可以使用矩阵。 矩阵是数字或其他数学对象的矩形数组，为其定义了运算（例如加法和乘法）。

矩阵用于计算，工程或图像处理。

matrix.py

  1. #!/usr/bin/env python
  3. from sympy import Matrix, pprint
  5. M = Matrix([[1, 2], [3, 4], [0, 3]])
  6. print(M)
  7. pprint(M)
  9. N = Matrix([2, 2])
  11. print("---------------------------")
  12. print("M * N")
  13. print("---------------------------")
  15. pprint(M*N)

该示例定义了两个矩阵并将它们相乘。

  1. $ matrix.py
  2. Matrix([[1, 2], [3, 4], [0, 3]])
  3. ⎡1  2⎤
  4. ⎢    ⎥
  5. ⎢3  4⎥
  6. ⎢    ⎥
  7. ⎣0  3⎦
  8. ---------------------------
  9. M * N
  10. ---------------------------
  11. ⎡6 ⎤
  12. ⎢  ⎥
  13. ⎢14⎥
  14. ⎢  ⎥
  15. ⎣6 ⎦

这是输出。

SymPy 绘图

SymPy 包含用于绘图的模块。 它基于 Matplotlib 构建。

simple_plot.py

  1. #!/usr/bin/env python
  3. # uses matplotlib
  5. import sympy
  6. from sympy.abc import x
  7. from sympy.plotting import plot
  9. plot(1/x)

该示例绘制了1/x函数的二维图。

这是 SymPy 教程。

您可能也对以下相关教程感兴趣： PrettyTable 教程， Matplotlib 教程， Python 教程。