SymPy是一款Python代数计算库，纯Python编写，软件目前只有1600的代码，包括算术、函数、替换和模式匹配等多种功能，可以在 LaTeX 中显示结果。涵盖微积分、解方程、矩阵、几何学、绘图等多种领域，让代码尽量的简单，方便理解和扩展。

基本介绍

SymPy是一个象征性的操作方案，纯Python写的。其目的是要成为一个全功能的Python代数计算库，同时保持为代码尽可能简单，以便理解和容易扩展。目前，Sympy目前只有1600的代码(包括注释行)，其功能包括基本的算术，基本简化，一系列扩大，功能(exp, ln, sin, cos, tan, 等)，分化，整合(目前只能做很简单的积分)，基本替代，任意精度的整数和有理数，标准(Python)的浮点，基本复杂的数字和符号的限制。

软件功能

核心功能包括基本算术、函数、替换、模式匹配等。

多项式

微积分

解方程

组合学

离散数学

矩阵

几何学

绘图

物理学

统计数据

密码学

解析

印刷

SymPy使用教程

SymPy

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

$ pip install sympy

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

Rational值

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

rational_values.py

#!/usr/bin/env python

from sympy import Rational

r1 = Rational(1/10)

r2 = Rational(1/10)

r3 = Rational(1/10)

val = (r1 + r2 + r3) * 3

print(val.evalf())

val2 = (1/10 + 1/10 + 1/10) * 3

print(val2)

Py该示例使用有理数。

val = (r1 + r2 + r3) * 3

print(val.evalf())

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

$ rational_values.py

0.900000000000000

0.9000000000000001

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

SymPy pprint

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

prettify.py

#!/usr/bin/env python

from sympy import pprint, Symbol, exp, sqrt

from sympy import init_printing

init_printing(use_unicode=True)

x = Symbol('x')

a = sqrt(2)

pprint(a)

print(a)

print("------------------------")

c = (exp(x) ** 2)/2

pprint(c)

print(c)

Py程序会美化输出。

init_printing(use_unicode=True)

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

$ prettify.py

√2

sqrt(2)

------------------------

2⋅x

ℯ

────

2

exp(2*x)/2

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

平方根

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

square_root.py

#!/usr/bin/env python

from sympy import sqrt, pprint, Mul

x = sqrt(2)

y = sqrt(2)

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

print('equals to ')

print(x * y)

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

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

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

$ square_root.py

√2⋅√2

equals to

2

Py这是输出。

SymPy 符号

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

def_sym.py

#!/usr/bin/env python

# ways to define symbols

from sympy import Symbol, symbols

from sympy.abc import x, y

expr = 2*x + 5*y

print(expr)

a = Symbol('a')

b = Symbol('b')

expr2 = a*b + a - b

print(expr2)

i, j = symbols('i j')

expr3 = 2*i*j + i*j

print(expr3)

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

from sympy.abc import x, y

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

a = Symbol('a')

b = Symbol('b')

Py可以用Symbol定义

i, j = symbols('i j')

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

SymPy 规范表达形式

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

canonical_form.py

#!/usr/bin/env python

from sympy.abc import a, b

expr = b*a + -4*a + b + a*b + 4*a + (a + b)*3

print(expr)

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

$ canonical_form.py

2*a*b + 3*a + 4*b

Py这是输出。

SymPy 扩展代数表达式

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

expand.py

#!/usr/bin/env python

from sympy import expand, pprint

from sympy.abc import x

expr = (x + 1) ** 2

pprint(expr)

print('-----------------------')

print('-----------------------')

expr = expand(expr)

pprint(expr)

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

$ expand.py

2

(x + 1)

-----------------------

-----------------------

2

x + 2⋅x + 1

Py这是输出。

SymPy 简化表达式

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

simplify.py

#!/usr/bin/env python

from sympy import sin, cos, simplify, pprint

from sympy.abc import x

expr = sin(x) / cos(x)

pprint(expr)

print('-----------------------')

expr = simplify(expr)

pprint(expr)

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

$ simplify.py

sin(x)

──────

cos(x)

-----------------------

tan(x)

Py这是输出。

SymPy 比较表达式

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

expr_equality.py

#!/usr/bin/env python

from sympy import pprint, Symbol, sin, cos

x = Symbol('x')

a = cos(x)**2 - sin(x)**2

b = cos(2*x)

print(a.equals(b))

# we cannot use == operator

print(a == b)

Py该程序比较两个表达式。

print(a.equals(b))

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

$ expr_equality.py

True

False

Py这是输出。

SymPy 求值表达式

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

evaluating.py

#!/usr/bin/env python

from sympy import pi

print(pi.evalf(30))

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

$ evaluating.py

3.14159265358979323846264338328

Py这是输出。

evaluating2.py

#!/usr/bin/env python

from sympy.abc import a, b

from sympy import pprint

expr = b*a + -4*a + b + a*b + 4*a + (a + b)*3

print(expr.subs([(a, 3), (b, 2)]))

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

$ evaluating.py

3.14159265358979323846264338328

Py这是输出。

SymPy 求解方程

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

solving.py

#!/usr/bin/env python

from sympy import Symbol, solve

x = Symbol('x')

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

print(sol)

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

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

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

$ solving.py

[0, 1]

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

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

solving2.py

#!/usr/bin/env python

from sympy import pprint, Symbol, Eq, solve

x = Symbol('x')

eq1 = Eq(x + 1, 4)

pprint(eq1)

sol = solve(eq1, x)

print(sol)

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

$ solving2.py

x + 1 = 4

[3]

Py这是输出。

solving3.py

#!/usr/bin/env python

from sympy.solvers import solveset

from sympy import Symbol, Interval, pprint

x = Symbol('x')

sol = solveset(x**2 - 1, x, Interval(0, 100))

print(sol)

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

$ solving3.py

{1}

Py这是输出。

SymPy 序列

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

sequence.py

#!/usr/bin/env python

from sympy import summation, sequence, pprint

from sympy.abc import x

s = sequence(x, (x, 1, 10))

print(s)

pprint(s)

print(list(s))

print(s.length)

print(summation(s.formula, (x, s.start, s.stop)))

# print(sum(list(s)))

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

$ sequence.py

SeqFormula(x, (x, 1, 10))

[1, 2, 3, 4, …]

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

10

55

Py这是输出。

SymPy 极限

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

limit.py

#!/usr/bin/env python

from sympy import sin, limit, oo

from sympy.abc import x

l1 = limit(1/x, x, oo)

print(l1)

l2 = limit(1/x, x, 0)

print(l2)

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

from sympy import sin, limit, sqrt, oo

Pyoo表示无穷大。

l1 = limit(1/x, x, oo)

print(l1)

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

$ limit.py

0

oo

Py这是输出。

SymPy 矩阵

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

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

matrix.py

#!/usr/bin/env python

from sympy import Matrix, pprint

M = Matrix([[1, 2], [3, 4], [0, 3]])

print(M)

pprint(M)

N = Matrix([2, 2])

print("---------------------------")

print("M * N")

print("---------------------------")

pprint(M*N)

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

$ matrix.py

Matrix([[1, 2], [3, 4], [0, 3]])

⎡1 2⎤

⎢ ⎥

⎢3 4⎥

⎢ ⎥

⎣0 3⎦

---------------------------

M * N

---------------------------

⎡6 ⎤

⎢ ⎥

⎢14⎥

⎢ ⎥

⎣6 ⎦

Py这是输出。

SymPy 绘图

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

simple_plot.py

#!/usr/bin/env python

# uses matplotlib

import sympy

from sympy.abc import x

from sympy.plotting import plot

plot(1/x)

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