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

PDF文件

下载需积分: 12 | 11.13MB | 更新于2024-07-15 | 201 浏览量 | 举报 1 收藏

立即下载

"sympy-docs-pdf-1.7.1.pdf是SymPy的英文帮助文档，涵盖了安装、教程、常见陷阱以及各个模块的参考信息。" SymPy是一个开源的Python库，专注于符号计算，它提供了广泛的功能，包括代数运算、微积分、求解方程、矩阵操作等。这个文档版本为1.7.1，由SymPy开发团队于2020年12月12日发布。 **1. 安装** - **Anaconda**: SymPy可以通过Anaconda数据科学平台进行安装，这使得依赖管理变得简单。 - **Git**: 用户可以直接从GitHub仓库克隆源代码来获取最新版本。 - **Other Methods**: 除了上述方法，还可以通过Python的pip工具直接安装。 - **Run SymPy**: 安装完成后，只需在Python环境中运行`import sympy`即可开始使用。 - **Mpmath**: Mpmath是SymPy的一个依赖库，用于提供高精度浮点计算。 **2. SymPy Tutorial** - **Preliminaries**: 入门前的基础知识，包括如何导入库和设置符号。 - **Introduction**: 介绍了SymPy的基本概念和用途。 - **Gotchas**: 提醒用户注意的一些陷阱，比如符号处理与常规编程的不同之处。 - **Basic Operations**: 展示了如何执行基本的符号计算，如加减乘除。 - **Printing**: 解释了如何控制SymPy表达式的打印格式。 - **Simplification**: 讲解了如何简化符号表达式，如因式分解和展开。 - **Calculus**: 包括导数、积分、极限等微积分操作。 - **Solvers**: 介绍了解方程和不等式的方法。 - **Matrices**: 教程涵盖了矩阵的创建、操作和求解线性系统。 - **Advanced Expression Manipulation**: 高级的表达式操纵技术，如替换、代换和函数定义。 **3. Gotchas and Pitfalls** - **Equals Signs (=)**: 强调了在SymPy中，'='并不表示数学上的等于，而是创建新的变量或表达式。 - **Variables**: 说明了如何正确地定义和使用变量。 - **Symbolic Expressions**: 解释了符号表达式的性质和行为。 - **Special Symbols**: 描述了一些特殊符号，如无限大（oo）和虚数单位（I）。 - **Getting help from within SymPy**: 介绍了在SymPy内部获取帮助的方法。 **4. SymPy Modules Reference** 这部分详细列出了SymPy各个模块的参考信息，如： - **abc**: 提供了预定义的字母符号。 - **Algebras**: 多项式环和代数结构的处理。 - **Assumptions**: 系统可以对符号进行假设，如正数、实数等。 - **Calculus**: 包含更高级的微积分功能。 - **...**: 其他众多模块，如代数、组合数学、具体数学、核心功能、密码学、微分几何等，涵盖广泛的数学领域。这些内容构成了一个全面的SymPy学习资源，无论是初学者还是有经验的开发者，都可以从中找到所需的信息，进一步提升在Python环境中进行符号计算的能力。

SymPy Documentation, Release 1.7.1

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 *.

10 Chapter 2. SymPy Tutorial

SymPy Documentation, Release 1.7.1

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.

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

2.3. Gotchas 11

SymPy Documentation, Release 1.7.1

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:

>>> (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 structurally. 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)

(continues on next page)

2.3. Gotchas 13

剩余2591页未读，继续阅读

plvorg

粉丝: 1

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

sympy-docs

sympy-1.5.1-py2.py3-none-any.whl

sympy-docs-pdf-1.0.pdf

sympy-docs-pdf-1.5.pdf

sympy-docs-pdf-1.6.pdf

sympy-docs-pdf-1.6.2.pdf

sympy-1.7.1.tar.gz

sympy-1.7.1-py3-none-any.whl

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

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

最新资源