SymPy 符号数学库教程 - Python 符号计算、微积分、方程求解、线性代数与物理计算

sympy by davila7/claude-code-templates

244 周安装量

24,200 GitHub Stars

GitHub

安装命令

npx skills add https://github.com/davila7/claude-code-templates --skill sympy

Python Web框架科研工具数据处理

🇨🇳中文介绍

SymPy - Python 中的符号数学

概述

SymPy 是一个用于符号数学的 Python 库，它支持使用数学符号进行精确计算，而非数值近似。本技能提供了使用 SymPy 进行符号代数、微积分、线性代数、方程求解、物理计算和代码生成的全面指导。

何时使用此技能

在以下情况下使用此技能：

符号化求解方程（代数方程、微分方程、方程组）
执行微积分运算（导数、积分、极限、级数）
操作和简化代数表达式
符号化处理矩阵和线性代数
进行物理计算（力学、量子力学、向量分析）
数论计算（素数、因式分解、模运算）
几何计算（2D/3D 几何、解析几何）
将数学表达式转换为可执行代码（Python、C、Fortran）
生成 LaTeX 或其他格式的数学输出
需要精确的数学结果（例如，sqrt(2) 而非 1.414...）

核心能力

1. 符号计算基础

创建符号和表达式：

from sympy import symbols, Symbol
x, y, z = symbols('x y z')
expr = x**2 + 2*x + 1

# 带假设
x = symbols('x', real=True, positive=True)
n = symbols('n', integer=True)

简化和操作：

from sympy import simplify, expand, factor, cancel
simplify(sin(x)**2 + cos(x)**2)  # 返回 1
expand((x + 1)**3)  # x**3 + 3*x**2 + 3*x + 1
factor(x**2 - 1)    # (x - 1)*(x + 1)

广告位招租

在这里展示您的产品或服务

触达数万 AI 开发者，精准高效

联系我们

4. 矩阵和线性代数

矩阵创建和运算：

from sympy import Matrix, eye, zeros
M = Matrix([[1, 2], [3, 4]])
M_inv = M**-1  # 逆矩阵
M.det()        # 行列式
M.T            # 转置

特征值和特征向量：

eigenvals = M.eigenvals()  # {特征值: 重数}
eigenvects = M.eigenvects()  # [(特征值, 重数, [特征向量])]
P, D = M.diagonalize()  # M = P*D*P^-1

求解线性系统：

A = Matrix([[1, 2], [3, 4]])
b = Matrix([5, 6])
x = A.solve(b)  # 求解 Ax = b

全面的线性代数： 参见 references/matrices-linear-algebra.md

from sympy.physics.mechanics import dynamicsymbols, LagrangesMethod
from sympy import symbols

# 定义系统
q = dynamicsymbols('q')
m, g, l = symbols('m g l')

# 拉格朗日量 (T - V)
L = m*(l*q.diff())**2/2 - m*g*l*(1 - cos(q))

# 应用拉格朗日方法
LM = LagrangesMethod(L, [q])

from sympy.physics.vector import ReferenceFrame, dot, cross
N = ReferenceFrame('N')
v1 = 3*N.x + 4*N.y
v2 = 1*N.x + 2*N.z
dot(v1, v2)  # 点积
cross(v1, v2)  # 叉积

from sympy.physics.quantum import Ket, Bra, Commutator
psi = Ket('psi')
A = Operator('A')
comm = Commutator(A, B).doit()

详细的物理能力： 参见 references/physics-mechanics.md

本技能全面支持：

几何： 2D/3D 解析几何、点、线、圆、多边形、变换
数论： 素数、因式分解、最大公约数/最小公倍数、模运算、丢番图方程
组合数学： 排列、组合、划分、群论
逻辑和集合： 布尔逻辑、集合论、有限集和无限集
统计学： 概率分布、随机变量、期望、方差
特殊函数： Gamma、Bessel、正交多项式、超几何函数
多项式： 多项式代数、根、因式分解、Gröbner 基

详细的高等主题： 参见 references/advanced-topics.md

7. 代码生成和输出

转换为可执行函数：

from sympy import lambdify
import numpy as np

expr = x**2 + 2*x + 1
f = lambdify(x, expr, 'numpy')  # 创建 NumPy 函数
x_vals = np.linspace(0, 10, 100)
y_vals = f(x_vals)  # 快速数值求值

生成 C/Fortran 代码：

from sympy.utilities.codegen import codegen
[(c_name, c_code), (h_name, h_header)] = codegen(
    ('my_func', expr), 'C'
)

from sympy import latex
latex_str = latex(expr)  # 转换为 LaTeX 用于文档

全面的代码生成： 参见 references/code-generation-printing.md

使用 SymPy：最佳实践

1. 始终先定义符号

from sympy import symbols
x, y, z = symbols('x y z')
# 现在 x, y, z 可以用于表达式

2. 使用假设以获得更好的简化效果

x = symbols('x', positive=True, real=True)
sqrt(x**2)  # 由于正数假设，返回 x（而非 Abs(x)）

常用假设：real, positive, negative, integer, rational, complex, even, odd

3. 使用精确算术

from sympy import Rational, S
# 正确（精确）：
expr = Rational(1, 2) * x
expr = S(1)/2 * x

# 错误（浮点数）：
expr = 0.5 * x  # 创建近似值

4. 需要时进行数值求值

from sympy import pi, sqrt
result = sqrt(8) + pi
result.evalf()    # 5.96371554103586
result.evalf(50)  # 50 位精度

5. 转换为 NumPy 以提高性能

# 多次求值时较慢：
for x_val in range(1000):
    result = expr.subs(x, x_val).evalf()

# 快速：
f = lambdify(x, expr, 'numpy')
results = f(np.arange(1000))

6. 使用合适的求解器

solveset: 代数方程（主要）
linsolve: 线性系统
nonlinsolve: 非线性系统
dsolve: 微分方程
solve: 通用目的（遗留，但灵活）

本技能使用模块化的参考文件来涵盖不同能力：

core-capabilities.md : 符号、代数、微积分、简化、方程求解
- 何时加载：进行基本符号计算、微积分或求解方程时
matrices-linear-algebra.md : 矩阵运算、特征值、线性系统
- 何时加载：处理矩阵或线性代数问题时
physics-mechanics.md : 经典力学、量子力学、向量、单位
- 何时加载：进行物理计算或力学问题时
advanced-topics.md : 几何、数论、组合数学、逻辑、统计学
- 何时加载：处理超出基本代数和微积分的高等数学主题时
code-generation-printing.md : Lambdify、codegen、LaTeX 输出、打印
- 何时加载：将表达式转换为代码或生成格式化输出时

模式 1：求解与验证

from sympy import symbols, solve, simplify
x = symbols('x')

# 求解方程
equation = x**2 - 5*x + 6
solutions = solve(equation, x)  # [2, 3]

# 验证解
for sol in solutions:
    result = simplify(equation.subs(x, sol))
    assert result == 0

模式 2：符号到数值的流水线

# 1. 定义符号问题
x, y = symbols('x y')
expr = sin(x) + cos(y)

# 2. 符号化操作
simplified = simplify(expr)
derivative = diff(simplified, x)

# 3. 转换为数值函数
f = lambdify((x, y), derivative, 'numpy')

# 4. 数值求值
results = f(x_data, y_data)

模式 3：记录数学结果

# 符号化计算结果
integral_expr = Integral(x**2, (x, 0, 1))
result = integral_expr.doit()

# 生成文档
print(f"LaTeX: {latex(integral_expr)} = {latex(result)}")
print(f"Pretty: {pretty(integral_expr)} = {pretty(result)}")
print(f"Numerical: {result.evalf()}")

与科学工作流的集成

import numpy as np
from sympy import symbols, lambdify

x = symbols('x')
expr = x**2 + 2*x + 1

f = lambdify(x, expr, 'numpy')
x_array = np.linspace(-5, 5, 100)
y_array = f(x_array)

import matplotlib.pyplot as plt
import numpy as np
from sympy import symbols, lambdify, sin

x = symbols('x')
expr = sin(x) / x

f = lambdify(x, expr, 'numpy')
x_vals = np.linspace(-10, 10, 1000)
y_vals = f(x_vals)

plt.plot(x_vals, y_vals)
plt.show()

from scipy.optimize import fsolve
from sympy import symbols, lambdify

# 符号化定义方程
x = symbols('x')
equation = x**3 - 2*x - 5

# 转换为数值函数
f = lambdify(x, equation, 'numpy')

# 使用初始猜测进行数值求解
solution = fsolve(f, 2)

快速参考：最常用函数

# 符号
from sympy import symbols, Symbol
x, y = symbols('x y')

# 基本运算
from sympy import simplify, expand, factor, collect, cancel
from sympy import sqrt, exp, log, sin, cos, tan, pi, E, I, oo

# 微积分
from sympy import diff, integrate, limit, series, Derivative, Integral

# 求解
from sympy import solve, solveset, linsolve, nonlinsolve, dsolve

# 矩阵
from sympy import Matrix, eye, zeros, ones, diag

# 逻辑和集合
from sympy import And, Or, Not, Implies, FiniteSet, Interval, Union

# 输出
from sympy import latex, pprint, lambdify, init_printing

# 实用工具
from sympy import evalf, N, nsimplify

示例 1：求解二次方程

from sympy import symbols, solve, sqrt
x = symbols('x')
solution = solve(x**2 - 5*x + 6, x)
# [2, 3]

示例 2：计算导数

from sympy import symbols, diff, sin
x = symbols('x')
f = sin(x**2)
df_dx = diff(f, x)
# 2*x*cos(x**2)

示例 3：求积分值

from sympy import symbols, integrate, exp
x = symbols('x')
integral = integrate(x * exp(-x**2), (x, 0, oo))
# 1/2

示例 4：矩阵特征值

from sympy import Matrix
M = Matrix([[1, 2], [2, 1]])
eigenvals = M.eigenvals()
# {3: 1, -1: 1}

示例 5：生成 Python 函数

from sympy import symbols, lambdify
import numpy as np
x = symbols('x')
expr = x**2 + 2*x + 1
f = lambdify(x, expr, 'numpy')
f(np.array([1, 2, 3]))
# array([ 4,  9, 16])

"NameError: name 'x' is not defined"
- 解决方案：始终在使用前使用 symbols() 定义符号
意外的数值结果
- 问题：使用了像 0.5 这样的浮点数，而不是 Rational(1, 2)
- 解决方案：使用 Rational() 或 S() 进行精确算术
循环中性能缓慢
- 问题：重复使用 subs() 和 evalf()
- 解决方案：使用 lambdify() 创建快速的数值函数
"无法求解此方程"
- 尝试不同的求解器：solve, solveset, nsolve（数值）
- 检查方程是否可代数求解
- 如果不存在闭式解，则使用数值方法
简化未按预期工作
- 尝试不同的简化函数：simplify, factor, expand, trigsimp
- 为符号添加假设（例如，positive=True）
- 使用 simplify(expr, force=True) 进行强力简化

🇺🇸English

SymPy - Symbolic Mathematics in Python

Overview

SymPy is a Python library for symbolic mathematics that enables exact computation using mathematical symbols rather than numerical approximations. This skill provides comprehensive guidance for performing symbolic algebra, calculus, linear algebra, equation solving, physics calculations, and code generation using SymPy.

When to Use This Skill

Use this skill when:

Solving equations symbolically (algebraic, differential, systems of equations)
Performing calculus operations (derivatives, integrals, limits, series)
Manipulating and simplifying algebraic expressions
Working with matrices and linear algebra symbolically
Doing physics calculations (mechanics, quantum mechanics, vector analysis)
Number theory computations (primes, factorization, modular arithmetic)
Geometric calculations (2D/3D geometry, analytic geometry)
Converting mathematical expressions to executable code (Python, C, Fortran)
Generating LaTeX or other formatted mathematical output
Needing exact mathematical results (e.g., sqrt(2) not 1.414...)

Core Capabilities

1. Symbolic Computation Basics

Creating symbols and expressions:

from sympy import symbols, Symbol
x, y, z = symbols('x y z')
expr = x**2 + 2*x + 1

# With assumptions
x = symbols('x', real=True, positive=True)
n = symbols('n', integer=True)

Simplification and manipulation:

from sympy import simplify, expand, factor, cancel
simplify(sin(x)**2 + cos(x)**2)  # Returns 1
expand((x + 1)**3)  # x**3 + 3*x**2 + 3*x + 1
factor(x**2 - 1)    # (x - 1)*(x + 1)

For detailed basics: See references/core-capabilities.md

2. Calculus

Derivatives:

from sympy import diff
diff(x**2, x)        # 2*x
diff(x**4, x, 3)     # 24*x (third derivative)
diff(x**2*y**3, x, y)  # 6*x*y**2 (partial derivatives)

Integrals:

from sympy import integrate, oo
integrate(x**2, x)              # x**3/3 (indefinite)
integrate(x**2, (x, 0, 1))      # 1/3 (definite)
integrate(exp(-x), (x, 0, oo))  # 1 (improper)

Limits and Series:

from sympy import limit, series
limit(sin(x)/x, x, 0)  # 1
series(exp(x), x, 0, 6)  # 1 + x + x**2/2 + x**3/6 + x**4/24 + x**5/120 + O(x**6)

For detailed calculus operations: See references/core-capabilities.md

3. Equation Solving

Algebraic equations:

from sympy import solveset, solve, Eq
solveset(x**2 - 4, x)  # {-2, 2}
solve(Eq(x**2, 4), x)  # [-2, 2]

Systems of equations:

from sympy import linsolve, nonlinsolve
linsolve([x + y - 2, x - y], x, y)  # {(1, 1)} (linear)
nonlinsolve([x**2 + y - 2, x + y**2 - 3], x, y)  # (nonlinear)

Differential equations:

from sympy import Function, dsolve, Derivative
f = symbols('f', cls=Function)
dsolve(Derivative(f(x), x) - f(x), f(x))  # Eq(f(x), C1*exp(x))

For detailed solving methods: See references/core-capabilities.md

4. Matrices and Linear Algebra

Matrix creation and operations:

from sympy import Matrix, eye, zeros
M = Matrix([[1, 2], [3, 4]])
M_inv = M**-1  # Inverse
M.det()        # Determinant
M.T            # Transpose

Eigenvalues and eigenvectors:

eigenvals = M.eigenvals()  # {eigenvalue: multiplicity}
eigenvects = M.eigenvects()  # [(eigenval, mult, [eigenvectors])]
P, D = M.diagonalize()  # M = P*D*P^-1

Solving linear systems:

A = Matrix([[1, 2], [3, 4]])
b = Matrix([5, 6])
x = A.solve(b)  # Solve Ax = b

For comprehensive linear algebra: See references/matrices-linear-algebra.md

5. Physics and Mechanics

Classical mechanics:

from sympy.physics.mechanics import dynamicsymbols, LagrangesMethod
from sympy import symbols

# Define system
q = dynamicsymbols('q')
m, g, l = symbols('m g l')

# Lagrangian (T - V)
L = m*(l*q.diff())**2/2 - m*g*l*(1 - cos(q))

# Apply Lagrange's method
LM = LagrangesMethod(L, [q])

Vector analysis:

from sympy.physics.vector import ReferenceFrame, dot, cross
N = ReferenceFrame('N')
v1 = 3*N.x + 4*N.y
v2 = 1*N.x + 2*N.z
dot(v1, v2)  # Dot product
cross(v1, v2)  # Cross product

Quantum mechanics:

from sympy.physics.quantum import Ket, Bra, Commutator
psi = Ket('psi')
A = Operator('A')
comm = Commutator(A, B).doit()

For detailed physics capabilities: See references/physics-mechanics.md

6. Advanced Mathematics

The skill includes comprehensive support for:

Geometry: 2D/3D analytic geometry, points, lines, circles, polygons, transformations
Number Theory: Primes, factorization, GCD/LCM, modular arithmetic, Diophantine equations
Combinatorics: Permutations, combinations, partitions, group theory
Logic and Sets: Boolean logic, set theory, finite and infinite sets
Statistics: Probability distributions, random variables, expectation, variance
Special Functions: Gamma, Bessel, orthogonal polynomials, hypergeometric functions
Polynomials: Polynomial algebra, roots, factorization, Groebner bases

For detailed advanced topics: See references/advanced-topics.md

7. Code Generation and Output

Convert to executable functions:

from sympy import lambdify
import numpy as np

expr = x**2 + 2*x + 1
f = lambdify(x, expr, 'numpy')  # Create NumPy function
x_vals = np.linspace(0, 10, 100)
y_vals = f(x_vals)  # Fast numerical evaluation

Generate C/Fortran code:

from sympy.utilities.codegen import codegen
[(c_name, c_code), (h_name, h_header)] = codegen(
    ('my_func', expr), 'C'
)

LaTeX output:

from sympy import latex
latex_str = latex(expr)  # Convert to LaTeX for documents

For comprehensive code generation: See references/code-generation-printing.md

Working with SymPy: Best Practices

1. Always Define Symbols First

from sympy import symbols
x, y, z = symbols('x y z')
# Now x, y, z can be used in expressions

2. Use Assumptions for Better Simplification

x = symbols('x', positive=True, real=True)
sqrt(x**2)  # Returns x (not Abs(x)) due to positive assumption

Common assumptions: real, positive, negative, integer, rational, complex, even, odd

3. Use Exact Arithmetic

from sympy import Rational, S
# Correct (exact):
expr = Rational(1, 2) * x
expr = S(1)/2 * x

# Incorrect (floating-point):
expr = 0.5 * x  # Creates approximate value

4. Numerical Evaluation When Needed

from sympy import pi, sqrt
result = sqrt(8) + pi
result.evalf()    # 5.96371554103586
result.evalf(50)  # 50 digits of precision

5. Convert to NumPy for Performance

# Slow for many evaluations:
for x_val in range(1000):
    result = expr.subs(x, x_val).evalf()

# Fast:
f = lambdify(x, expr, 'numpy')
results = f(np.arange(1000))

6. Use Appropriate Solvers

solveset: Algebraic equations (primary)
linsolve: Linear systems
nonlinsolve: Nonlinear systems
dsolve: Differential equations
solve: General purpose (legacy, but flexible)

Reference Files Structure

This skill uses modular reference files for different capabilities:

core-capabilities.md : Symbols, algebra, calculus, simplification, equation solving
- Load when: Basic symbolic computation, calculus, or solving equations
matrices-linear-algebra.md : Matrix operations, eigenvalues, linear systems
- Load when: Working with matrices or linear algebra problems
physics-mechanics.md : Classical mechanics, quantum mechanics, vectors, units
- Load when: Physics calculations or mechanics problems
advanced-topics.md : Geometry, number theory, combinatorics, logic, statistics
- Load when: Advanced mathematical topics beyond basic algebra and calculus
code-generation-printing.md : Lambdify, codegen, LaTeX output, printing

Common Use Case Patterns

Pattern 1: Solve and Verify

from sympy import symbols, solve, simplify
x = symbols('x')

# Solve equation
equation = x**2 - 5*x + 6
solutions = solve(equation, x)  # [2, 3]

# Verify solutions
for sol in solutions:
    result = simplify(equation.subs(x, sol))
    assert result == 0

Pattern 2: Symbolic to Numeric Pipeline

# 1. Define symbolic problem
x, y = symbols('x y')
expr = sin(x) + cos(y)

# 2. Manipulate symbolically
simplified = simplify(expr)
derivative = diff(simplified, x)

# 3. Convert to numerical function
f = lambdify((x, y), derivative, 'numpy')

# 4. Evaluate numerically
results = f(x_data, y_data)

Pattern 3: Document Mathematical Results

# Compute result symbolically
integral_expr = Integral(x**2, (x, 0, 1))
result = integral_expr.doit()

# Generate documentation
print(f"LaTeX: {latex(integral_expr)} = {latex(result)}")
print(f"Pretty: {pretty(integral_expr)} = {pretty(result)}")
print(f"Numerical: {result.evalf()}")

Integration with Scientific Workflows

With NumPy

import numpy as np
from sympy import symbols, lambdify

x = symbols('x')
expr = x**2 + 2*x + 1

f = lambdify(x, expr, 'numpy')
x_array = np.linspace(-5, 5, 100)
y_array = f(x_array)

With Matplotlib

import matplotlib.pyplot as plt
import numpy as np
from sympy import symbols, lambdify, sin

x = symbols('x')
expr = sin(x) / x

f = lambdify(x, expr, 'numpy')
x_vals = np.linspace(-10, 10, 1000)
y_vals = f(x_vals)

plt.plot(x_vals, y_vals)
plt.show()

With SciPy

from scipy.optimize import fsolve
from sympy import symbols, lambdify

# Define equation symbolically
x = symbols('x')
equation = x**3 - 2*x - 5

# Convert to numerical function
f = lambdify(x, equation, 'numpy')

# Solve numerically with initial guess
solution = fsolve(f, 2)

Quick Reference: Most Common Functions

# Symbols
from sympy import symbols, Symbol
x, y = symbols('x y')

# Basic operations
from sympy import simplify, expand, factor, collect, cancel
from sympy import sqrt, exp, log, sin, cos, tan, pi, E, I, oo

# Calculus
from sympy import diff, integrate, limit, series, Derivative, Integral

# Solving
from sympy import solve, solveset, linsolve, nonlinsolve, dsolve

# Matrices
from sympy import Matrix, eye, zeros, ones, diag

# Logic and sets
from sympy import And, Or, Not, Implies, FiniteSet, Interval, Union

# Output
from sympy import latex, pprint, lambdify, init_printing

# Utilities
from sympy import evalf, N, nsimplify

Getting Started Examples

Example 1: Solve Quadratic Equation

from sympy import symbols, solve, sqrt
x = symbols('x')
solution = solve(x**2 - 5*x + 6, x)
# [2, 3]

Example 2: Calculate Derivative

from sympy import symbols, diff, sin
x = symbols('x')
f = sin(x**2)
df_dx = diff(f, x)
# 2*x*cos(x**2)

Example 3: Evaluate Integral

from sympy import symbols, integrate, exp
x = symbols('x')
integral = integrate(x * exp(-x**2), (x, 0, oo))
# 1/2

Example 4: Matrix Eigenvalues

from sympy import Matrix
M = Matrix([[1, 2], [2, 1]])
eigenvals = M.eigenvals()
# {3: 1, -1: 1}

Example 5: Generate Python Function

from sympy import symbols, lambdify
import numpy as np
x = symbols('x')
expr = x**2 + 2*x + 1
f = lambdify(x, expr, 'numpy')
f(np.array([1, 2, 3]))
# array([ 4,  9, 16])

Troubleshooting Common Issues

"NameError: name 'x' is not defined"
- Solution: Always define symbols using symbols() before use
Unexpected numerical results
- Issue: Using floating-point numbers like 0.5 instead of Rational(1, 2)
- Solution: Use Rational() or S() for exact arithmetic
Slow performance in loops
- Issue: Using subs() and evalf() repeatedly
- Solution: Use lambdify() to create a fast numerical function

Additional Resources

Official Documentation: https://docs.sympy.org/
Tutorial: https://docs.sympy.org/latest/tutorials/intro-tutorial/index.html
API Reference: https://docs.sympy.org/latest/reference/index.html
Examples: https://github.com/sympy/sympy/tree/master/examples

Weekly Installs

192

Repository

davila7/claude-…emplates

GitHub Stars

23.4K

First Seen

Jan 21, 2026

Security Audits

Gen Agent Trust HubPass SocketPass SnykPass

Installed on

opencode161

gemini-cli151

claude-code149

cursor146

codex141

github-copilot133

Apify Actor 输出模式生成工具 - 自动化创建 dataset_schema.json 与 output_schema.json

1,300 周安装

Load when: Converting expressions to code or generating formatted output

"Can't solve this equation"

Try different solvers: solve, solveset, nsolve (numerical)
Check if the equation is solvable algebraically
Use numerical methods if no closed-form solution exists

Simplification not working as expected

Try different simplification functions: simplify, factor, expand, trigsimp
Add assumptions to symbols (e.g., positive=True)
Use simplify(expr, force=True) for aggressive simplification