SymPy 1.5官方文档：Python符号计算指南

需积分: 10 95 浏览量更新于2024-07-16 收藏 8.22MB PDF 举报

SymPy-docs-pdf-1.5.pdf是一份关于Python符号计算库SymPy的官方文档，发布于2019年12月9日。这份文档详尽地介绍了如何安装SymPy及其各种功能，以及如何避免常见问题和陷阱。 **1. 安装与支持** 文档首先介绍了几种安装SymPy的方法，包括通过Anaconda（一个流行的Python发行版）和Git源代码管理工具。此外，还提到了可能遇到的问题，如使用不同方法安装时的注意事项。 **2. SymPy教程** - **Preliminaries**：文档概述了SymPy的基本概念和环境设置。 - **Introduction**：新手指南介绍了SymPy的主要用途和基本操作，如变量定义、表达式处理等。 - **Gotchas and Pitfalls**：这部分列举了一些使用SymPy时可能遇到的常见问题，如理解等于号（=）在符号计算中的行为、正确处理变量和符号表达式等。 - **Advanced Expression Manipulation**：深入讲解了如何进行高级表达式操作，如简化、微积分和解方程。 **3. 用户指南** - **Introduction**：用户指南旨在帮助读者学习和掌握SymPy，包括如何系统性地学习库的使用。 - **Learning SymPy**：这部分提供了一些建议和路径，帮助读者逐步提高SymPy技能。 - **Architecture**：阐述了SymPy库的设计架构，有助于理解其内部工作原理。 - **Contributing**：鼓励用户参与SymPy的开发和贡献，说明了如何向社区贡献自己的代码和改进。 **4. SymPy模块参考** 文档详细列出了SymPy库中的各个模块，包括但不限于： - `abc`：抽象代数构造 - `Algebras`：代数结构 - `Assumptions`：假设和条件处理 - `Calculus`：微积分函数和工具 - `Category Theory`：范畴论支持 - `Code Generation`：代码生成能力 - `Combinatorics`：组合数学 - `Concrete`：具体领域数学对象 - `Core`：核心功能模块 - `Cryptography`：密码学应用 - `Differential Geometry`：微分几何 - `Diophantine`：迪奥菲努斯方程求解 - `Discrete`：离散数学 - `Functions`：各种数学函数支持通过阅读这份文档，用户可以了解到如何有效地使用SymPy进行符号计算、解决数学问题，并了解如何扩展和完善这个强大的Python库。对于任何对符号计算感兴趣或者在开发过程中需要此类功能的开发者来说，这是一份不可或缺的参考资料。

SymPy Documentation, Release 1.5

2.2.4 Why SymPy?

There are many computer algebra systems out there. This Wikipedia article lists many of

them. What makes SymPy a better choice than the alternatives?

First oﬀ, SymPy is completely free. It is open source, and licensed under the liberal BSD

license, so you can modify the source code and even sell it if you want to. This contrasts

with popular commercial systems like Maple or Mathematica that cost hundreds of dollars in

licenses.

Second, SymPy uses Python. Most computer algebra systems invent their own language.

Not SymPy. SymPy is written entirely in Python, and is executed entirely in Python. This

means that if you already know Python, it is much easier to get started with SymPy, because

you already know the syntax (and if you don’t know Python, it is really easy to learn). We

already know that Python is a well-designed, battle-tested language. The SymPy developers

are conﬁdent in their abilities in writing mathematical software, but programming language

design is a completely diﬀerent thing. By reusing an existing language, we are able to focus

on those things that matter: the mathematics.

Another computer algebra system, Sage also uses Python as its language. But Sage is large,

with a download of over a gigabyte. An advantage of SymPy is that it is lightweight. In

addition to being relatively small, it has no dependencies other than Python, so it can be used

almost anywhere easily. Furthermore, the goals of Sage and the goals of SymPy are diﬀerent.

Sage aims to be a full featured system for mathematics, and aims to do so by compiling all the

major open source mathematical systems together into one. When you call some function in

Sage, such as integrate, it calls out to one of the open source packages that it includes. In

fact, SymPy is included in Sage. SymPy on the other hand aims to be an independent system,

with all the features implemented in SymPy itself.

A ﬁnal important feature of SymPy is that it can be used as a library. Many computer algebra

systems focus on being usable in interactive environments, but if you wish to automate or

extend them, it is diﬀicult to do. With SymPy, you can just as easily use it in an interactive

Python environment or import it in your own Python application. SymPy also provides APIs

to make it easy to extend it with your own custom functions.

2.3 Gotchas

To begin, we should make something about SymPy clear. SymPy is nothing more than a Python

library, like NumPy, Django, or even modules in the Python standard library sys or re. What

this means is that SymPy does not add anything to the Python language. Limitations that are

inherent in the Python language are also inherent in SymPy. It also means that SymPy tries

to use Python idioms whenever possible, making programming with SymPy easy for those

already familiar with programming with Python. As a simple example, SymPy uses Python

syntax to build expressions. Implicit multiplication (like 3x or 3 x) is not allowed in Python,

and thus not allowed in SymPy. To multiply 3 and x, you must type 3*x with the *.

2.3.1 Symbols

One consequence of this fact is that SymPy can be used in any environment where Python is

available. We just import it, like we would any other library:

>>> from sympy import *

10 Chapter 2. SymPy Tutorial

SymPy Documentation, Release 1.5

This imports all the functions and classes from SymPy into our interactive Python session.

Now, suppose we start to do a computation.

>>> x + 1

Traceback (most recent call last):

...

NameError: name 'x' is not defined

Oops! What happened here? We tried to use the variable x, but it tells us that x is not deﬁned.

In Python, variables have no meaning until they are deﬁned. SymPy is no diﬀerent. Unlike

many symbolic manipulation systems you may have used, in SymPy, variables are not deﬁned

automatically. To deﬁne variables, we must use symbols.

>>> x = symbols('x')

>>> x + 1

x + 1

symbols takes a string of variable names separated by spaces or commas, and creates Sym-

bols out of them. We can then assign these to variable names. Later, we will investigate some

convenient ways we can work around this issue. For now, let us just deﬁne the most common

variable names, x, y, and z, for use through the rest of this section

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

As a ﬁnal note, we note that the name of a Symbol and the name of the variable it is assigned

to need not have anything to do with one another.

>>> a, b = symbols('b a')

>>> a

>>> b

Here we have done the very confusing thing of assigning a Symbol with the name a to the

variable b, and a Symbol of the name b to the variable a. Now the Python variable named a

points to the SymPy Symbol named b, and visa versa. How confusing. We could have also

done something like

>>> crazy = symbols('unrelated')

>>> crazy + 1

unrelated + 1

This also shows that Symbols can have names longer than one character if we want.

Usually, the best practice is to assign Symbols to Python variables of the same name, although

there are exceptions: Symbol names can contain characters that are not allowed in Python

variable names, or may just want to avoid typing long names by assigning Symbols with long

names to single letter Python variables.

To avoid confusion, throughout this tutorial, Symbol names and Python variable names will

always coincide. Furthermore, the word “Symbol” will refer to a SymPy Symbol and the word

“variable” will refer to a Python variable.

Finally, let us be sure we understand the diﬀerence between SymPy Symbols and Python

variables. Consider the following:

2.3. Gotchas 11

SymPy Documentation, Release 1.5

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)

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 structural 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 25)

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. Gotchas 13

剩余2349页未读，继续阅读

bctemg

粉丝: 0
资源: 1

SymPy 1.5官方文档：Python符号计算指南

Python-SymPy一个纯Python编写的计算机代数系统

Python Sympy计算梯度、散度和旋度的实例

sympy-docs-pdf-1.6.pdf

sympy-docs-pdf-1.7.1.pdf

sympy-docs-pdf-1.0.pdf

sympy-docs-pdf-1.6.2.pdf

sympy-docs

sympy安装包及pdf文档

Sympy 1.11版本安装包与官方PDF文档下载

SymPy 1.7.1官方文档：Python数学符号处理指南

最新资源