SymPy 1.1.1 符号计算入门与指南

需积分: 50 66 浏览量更新于2024-07-18 收藏 5.89MB PDF 举报

"sympy1.1.1文档是一个关于SymPy的详细教程和参考指南，涵盖了从安装到高级表达式操作的所有内容。" SymPy是Python中的一个强大的开源符号计算库，它允许用户进行数学符号运算，适用于科学研究、教育以及其他需要精确数学计算的领域。在Python 2.7及以上版本中，可以方便地安装和使用SymPy。 1. **安装** SymPy的安装可以通过多种方法完成： - **Anaconda**：对于那些已经使用Anaconda环境的用户，可以通过conda命令轻松安装。 - **Git**：开发者或想要获取最新版本的用户可以直接从GitHub仓库克隆源代码。 - **其他方法**：包括使用pip等Python包管理器来安装预编译的版本。 - **运行SymPy**：安装完成后，只需在Python环境中导入sympy模块即可开始使用。 2. **SymPy教程** 教程分为多个部分，从基础到进阶，帮助用户快速上手： - **Preliminaries**：介绍必要的预备知识。 - **Introduction**：解释SymPy的基本概念和用途。 - **Gotchas**：列出可能遇到的问题和陷阱，帮助用户避免常见错误。 - **Basic Operations**：展示如何进行基本的符号运算，如加减乘除、指数和对数等。 - **Printing**：讨论如何控制和定制SymPy表达式的打印方式。 - **Simplification**：介绍简化表达式的方法，如化简、因式分解等。 - **Calculus**：涵盖微积分功能，如求导、积分、极限等。 - **Solvers**：讲解如何解决各种类型的方程和不等式。 - **Matrices**：介绍矩阵操作，包括矩阵的创建、运算和解线性方程组。 - **Advanced Expression Manipulation**：深入探讨复杂的表达式操纵技巧。 3. **Gotchas and Pitfalls** 这一部分专门讨论在使用SymPy时需要注意的问题，例如： - **Equals Signs (=)**：在Python中，'='表示赋值，而在数学中代表等式。SymPy使用`==`进行等式比较。 - **Variables**：SymPy中的变量需要先定义为symbol对象。 - **Symbolic Expressions**：解释如何创建和处理符号表达式。 - **Special Symbols**：介绍如pi、e等特殊符号的用法。 - **Getting help from within SymPy**：讲解如何在SymPy内部获取帮助信息。 4. **SymPy User's Guide** 用户指南提供了学习SymPy的资源和贡献方法，以及对SymPy架构的概述。 5. **SymPy Modules Reference** 最后一部分是模块参考，详细列出了SymPy包含的各种模块和功能： - **SymPy Core**：核心模块，包含基本的符号对象和运算。 - **Combinatorics Module**：提供组合数学的功能。 - **Number Theory**：支持数论操作。 - **Basic Cryptography Module**：用于基础密码学的函数。 - **Concrete Mathematics**：涵盖具体的数学运算。 - **Numerical Evaluation**：处理数值计算。 - **Code Generation with SymPy**：生成可执行代码的细节。 - **Numeric Computation**：数值计算相关的工具。 - **Functions Module**：包含各种数学函数。 - **Geometry**：几何相关的功能。 SymPy1.1.1文档是一个全面的学习资源，无论是初学者还是经验丰富的开发者，都能从中受益，掌握符号计算的精髓。通过阅读和实践文档中的内容，用户将能够利用Python进行复杂的数学运算，解决数学问题，并开发出与数学相关的应用。

SymPy Documentation, Release 1.1.1

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 *

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.

10 Chapter 2. SymPy Tutorial

SymPy Documentation, Release 1.1.1

>>> 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:

x = symbols(’x’)

expr = x + 1

x = 2

print(expr)

What do you think the output of this code will be? If you thought 3, you’re wrong. Let’s see

what really happens

>>> x = symbols(’x’)

>>> expr = x + 1

>>> x = 2

>>> print(expr)

x + 1

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.

2.3. Gotchas 11

SymPy Documentation, Release 1.1.1

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)

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:

12 Chapter 2. SymPy Tutorial

SymPy Documentation, Release 1.1.1

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

剩余1877页未读，继续阅读

lvhuanwen

粉丝: 0
资源: 3

SymPy 1.1.1 符号计算入门与指南

sympy-docs-pdf-1.6.2.pdf

sympy_doc:SymPy文档资料库

sympy库说明文档-sympy库说明文档

SymPy 1.1.1 documentation

sympy安装包及pdf文档

sympy的码源包（1.1.1版本）

sympy-docs-pdf-1.7.1.pdf

sympy-docs-pdf-1.0.pdf

sympy-docs-pdf-1.5.pdf

sympy-docs-pdf-1.6.pdf

最新资源