SymPy 1.0官方文档：安装教程与核心模块详解

需积分: 12 119 浏览量更新于2024-07-20 收藏 8.99MB PDF 举报

《SymPy官方文档PDF版 1.0》是一份详细的文档，由SymPy开发团队于2016年3月发布。该文档涵盖了SymPy软件的安装指南、教程、常见问题和陷阱、用户指南以及模块参考等内容。以下是主要知识点概览： 1. **安装**: - **Anaconda**: 提供了一种便捷的方式安装SymPy，适合那些想要快速集成科学计算工具包的用户。 - **Git**: 如果你想直接从源代码仓库管理SymPy，文档介绍了如何使用Git进行版本控制和克隆项目。 - **其他方法**: 对于其他安装选项和配置，包括系统包管理器（如apt或yum）的安装步骤也有所涉及。 2. **SymPy Tutorial**: - **Preliminaries**: 入门章节，介绍了SymPy的基本环境设置和环境配置。 - **Introduction**: 概述了SymPy的主要功能，如符号计算、数学表达式处理和方程求解等。 - **Gotchas and Pitfalls**: 提醒用户注意的一些常见问题和陷阱，例如错误的符号使用和误解等。 - **Specific topics**: - **Basic Operations**: 如变量定义、基本算术运算和函数应用。 - **Printing**: 控制SymPy表达式的输出格式。 - **Simplification**: 学习如何简化复杂的数学表达式。 - **Calculus**: 提供微积分操作的支持，如极限、导数和积分。 - **Solvers**: 解方程、不等式和系统方程的能力。 - **Matrices**: 处理矩阵运算和线性代数问题。 - **Advanced Expression Manipulation**: 更高级的表达式操作技巧。 3. **Gotchas and Pitfalls**: - **equals signs (=)**: 关于赋值和比较符号的正确使用。 - **Variables**: 符号变量和全局作用域的理解。 - **Symbolic Expressions**: 符号表达式的特性及其与数值计算的区别。 - **Special Symbols**: 如特殊函数、常数和符号的区别。 4. **SymPy User's Guide**: - **Introduction**: 对用户的角色和如何开始使用SymPy进行深入学习的介绍。 - **Learning SymPy**: 提供学习路径和资源建议，帮助用户逐步掌握SymPy。 - **Architecture**: 描述SymPy的设计思想和模块结构。 - **Contributing**: 鼓励用户参与SymPy社区，提供贡献指南。 5. **SymPy Modules Reference**: - **Core**: 对核心模块的详细描述，包括符号计算、函数库等。 - **Combinatorics**: 提供组合数学相关的工具和函数。 - **Number Theory**: 数论模块的功能，如质数检查、欧几里得算法等。 - **Basic Cryptography**: 包含基础加密算法实现。 - **Concrete Mathematics**: 实用数学工具集。 - **Numeric Evaluation**: 数值评估和近似计算的方法。 - **Code Generation**: 代码生成方面的细节，用于将SymPy表达式转化为其他语言代码。 - **Numeric Computation**: 基于数值计算的模块和功能。 - **Functions Module**: 函数相关的工具，如特殊函数和用户自定义函数。 - **Geometry**: 提供几何学相关的支持，如点、直线、多边形等。这份文档是全面了解和使用SymPy的强大资源，无论是初学者还是专业开发者，都可以从中找到所需的信息来提升数学计算能力和Python编程技能。

SymPy Documentation, Release 1.0

Changing x to 2 had no eﬀect on expr. This is because x = 2 changes the Python variable

x to 2, but has no eﬀect on the SymPy Symbol x, which was what we used in creating expr.

When we created expr, the Python variable x was a Symbol. After we created, it, we changed

the Python variable x to 2. But expr remains the same. This behavior is not unique to SymPy.

All Python programs work this way: if a variable is changed, expressions that were already

created with that variable do not change automatically. For example

>>> x = ’abc’

>>> expr = x + ’def’

>>> expr

’abcdef’

>>> x = ’ABC’

>>> expr

’abcdef’

Quick Tip

To change the value of a Symbol in an expression, use subs

>>> x = symbols(’x’)

>>> expr = x + 1

>>> expr.subs(x, 2)

In this example, if we want to know what expr is with the new value of x, we need to reevaluate

the code that created expr, namely, expr = x + 1. This can be complicated if several lines

created expr. One advantage of using a symbolic computation system like SymPy is that we

can build a symbolic representation for expr, and then substitute x with values. The correct

way to do this in SymPy is to use subs, which will be discussed in more detail later.

>>> x = symbols(’x’)

>>> expr = x + 1

>>> expr.subs(x, 2)

2.3.2 Equals signs

Another very important consequence of the fact that SymPy does not extend Python syntax is

that = does not represent equality in SymPy. Rather it is Python variable assignment. This is

hard-coded into the Python language, and SymPy makes no attempts to change that.

You may think, however, that ==, which is used for equality testing in Python, is used for

SymPy as equality. This is not quite correct either. Let us see what happens when we use ==.

>>> x + 1 == 4

False

Instead of treating x + 1 == 4 symbolically, we just got False. In SymPy, == represents exact

structural equality testing. This means that a == b means that we are asking if a = b. We

always get a bool as the result of ==. There is a separate object, called Eq, which can be used

to create symbolic equalities

>>> Eq(x + 1, 4)

Eq(x + 1, 4)

10 Chapter 2. SymPy Tutorial

SymPy Documentation, Release 1.0

There is one additional caveat about == as well. Suppose we want to know if (x+1)

= x

+2x+1.

We might try something like this:

>>> (x + 1)**2 == x**2 + 2*x + 1

False

We got False again. However, (x + 1)

does equal x

+ 2x + 1. What is going on here? Did we

ﬁnd a bug in SymPy, or is it just not powerful enough to recognize this basic algebraic fact?

Recall from above that == represents exact structural equality testing. “Exact” here means

that two expressions will compare equal with == only if they are exactly equal structurally.

Here, (x + 1)

and x

+ 2x + 1 are not the same symbolically. One is the power of an addition of

two terms, and the other is the addition of three terms.

It turns out that when using SymPy as a library, having == test for exact symbolic equality is

far more useful than having it represent symbolic equality, or having it test for mathematical

equality. However, as a new user, you will probably care more about the latter two. We have

already seen an alternative to representing equalities symbolically, Eq. To test if two things

are equal, it is best to recall the basic fact that if a = b, then a − b = 0. Thus, the best way to

check if a = b is to take a−b and simplify it, and see if it goes to 0. We will learn later (page 21)

that the function to do this is called simplify. This method is not infallible—in fact, it can

be theoretically proven that it is impossible to determine if two symbolic expressions are

identically equal in general—but for most common expressions, it works quite well.

>>> a = (x + 1)**2

>>> b = x**2 + 2*x + 1

>>> simplify(a - b)

>>> c = x**2 - 2*x + 1

>>> simplify(a - c)

4*x

There is also a method called equals that tests if two expressions are equal by evaluating

them numerically at random points.

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

>>> b = cos(2*x)

>>> a.equals(b)

True

2.3.3 Two Final Notes: ˆ and /

You may have noticed that we have been using ** for exponentiation instead of the standard ˆ.

That’s because SymPy follows Python’s conventions. In Python, ˆ represents logical exclusive

or. SymPy follows this convention:

>>> True ^ False

True

>>> True ^ True

False

>>> x^y

Xor(x, y)

Finally, a small technical discussion on how SymPy works is in order. When you type some-

thing like x + 1, the SymPy Symbol x is added to the Python int 1. Python’s operator rules

then allow SymPy to tell Python that SymPy objects know how to be added to Python ints, and

so 1 is automatically converted to the SymPy Integer object.

2.3. Gotchas 11

SymPy Documentation, Release 1.0

2.3.4 Further Reading

For more discussion on the topics covered in this section, see Gotchas and Pitfalls (page 59).

2.4 Basic Operations

Here we discuss some of the most basic operations needed for expression manipulation in

SymPy. Some more advanced operations will be discussed later in the advanced expression

manipulation (page 51) section.

>>> from sympy import *

>>> x, y, z = symbols(”x y z”)

2.4.1 Substitution

One of the most common things you might want to do with a mathematical expression is

substitution. Substitution replaces all instances of something in an expression with something

else. It is done using the subs method. For example

>>> expr = cos(x) + 1

>>> expr.subs(x, y)

cos(y) + 1

Substitution is usually done for one of two reasons:

1. Evaluating an expression at a point. For example, if our expression is cos(x) + 1 and

we want to evaluate it at the point x = 0, so that we get cos(0) + 1, which is 2.

>>> expr.subs(x, 0)

2. Replacing a subexpression with another subexpression. There are two reasons we might

want to do this. The ﬁrst is if we are trying to build an expression that has some symme-

try, such as x

. To build this, we might start with x**y, and replace y with x**y. We

would then get x**(x**y). If we replaced y in this new expression with x**x, we would

get x**(x**(x**x)), the desired expression.

>>> expr = x**y

>>> expr

x**y

>>> expr = expr.subs(y, x**y)

>>> expr

x**(x**y)

>>> expr = expr.subs(y, x**x)

>>> expr

x**(x**(x**x))

The second is if we want to perform a very controlled simpliﬁcation, or perhaps a simpli-

ﬁcation that SymPy is otherwise unable to do. For example, say we have sin(2x)+cos(2x),

and we want to replace sin(2x) with 2 sin(x) cos(x). As we will learn later, the function

expand trig does this. However, this function will also expand cos(2x), which we may

not want. While there are ways to perform such precise simpliﬁcation, and we will learn

some of them in the advanced expression manipulation (page 51) section, an easy way

is to just replace sin(2x) with 2 sin(x) cos(x).

2.4. Basic Operations 13

剩余1784页未读，继续阅读

l888888h

粉丝: 47
资源: 42

SymPy 1.0官方文档：安装教程与核心模块详解

sympy_doc:SymPy文档资料库

python sympy 符号运算库 文档

sympy-docs-pdf-1.6.pdf

sympy-docs-pdf-1.5.pdf

sympy-docs-pdf-1.7.1.pdf

sympy-docs-pdf-1.6.2.pdf

sympy-1.0.tar.gz

sympy-docs

sympy-live:live.sympy.org上的代码源

Algebra_with_SymPy-0.9.1.1-py3-none-any.whl.zip

最新资源

python sympy 符号运算库文档