SymPy 1.6 官方文档：科学计算与数学符号处理

需积分: 9 173 浏览量更新于2024-07-15 收藏 8.51MB PDF 举报

"sympy-docs-pdf-1.6.pdf 是一份关于 SymPy 的科学计算文档，涵盖了从安装到高级表达式操作的多个主题。这份官方文档详细介绍了 SymPy 的功能，包括求解器、矩阵运算、微积分、简化表达式等，并提供了常见问题和陷阱的解答。" SymPy 是一个 Python 库，专门用于符号计算，它在数学、物理以及工程领域的建模和计算中发挥着重要作用。以下是对文档中部分关键知识点的详细说明： 1. **安装**： - **Anaconda**: Anaconda 是一个广泛使用的 Python 数据科学平台，其中包含了 SymPy 及其他相关库。 - **Git**: 你可以通过 Git 下载 SymPy 的源代码并进行安装，这适合开发者和想要参与项目的人。 - **Other Methods**: 还有其他方法安装，例如使用 Python 的包管理器 pip。 - **Run SymPy**: 安装完成后，只需在 Python 解释器中导入 SymPy 就可以开始使用。 2. **SymPy Tutorial**： - **Preliminaries**: 提供了初步了解 SymPy 的基础知识。 - **Introduction**: 介绍 SymPy 的核心概念和如何开始使用。 - **Gotchas**: 针对新手可能遇到的问题和陷阱进行预警。 - **Basic Operations**: 展示基本的符号计算操作，如创建符号、加减乘除。 - **Printing**: 讨论如何控制输出的格式，使得表达式更易读。 - **Simplification**: 描述了如何简化复杂的数学表达式。 - **Calculus**: 包括微积分操作，如求导、积分、极限等。 - **Solvers**: 解方程和不等式的方法。 - **Matrices**: 教你如何处理矩阵运算。 - **Advanced Expression Manipulation**: 进阶表达式操作，如函数替换、展开、因式分解等。 3. **Gotchas and Pitfalls**： - **Equals Signs (=)**: 在 SymPy 中，`=` 不表示数学上的相等，而是赋值操作符。 - **Variables**: 强调变量在 SymPy 中的特殊性，需要使用 `symbols()` 创建符号。 - **Symbolic Expressions**: 解释了如何创建和操作符号表达式。 - **Special Symbols**: 提及了一些预定义的特殊符号，如 Pi、E 等。 - **Getting help from within SymPy**: 如何在 SymPy 中获取关于函数或模块的帮助。 4. **SymPy Modules Reference**： - 这一部分是 SymPy 各个模块的详细参考，包括但不限于代数、假设系统、微积分、类别理论、代码生成、组合数学、具体数学、核心模块、密码学、微分几何、丢番图方程、离散数学、数值评估、函数、几何、拟合多项式、超几何展开和不等式系统等。文档还包含了更多关于每个模块的子主题和用例，是深入学习和使用 SymPy 的宝贵资源。对于任何需要进行符号计算的 Python 开发者，掌握 SymPy 的这些知识点都是至关重要的。

SymPy Documentation, Release 1.6

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

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

2.3. Gotchas 11

SymPy Documentation, Release 1.6

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

(continues on next page)

2.3. Gotchas 13

剩余2469页未读，继续阅读

模块电源

粉丝: 0
资源: 1

SymPy 1.6 官方文档：科学计算与数学符号处理

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

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

sympy-docs-pdf-1.0.pdf

import sympy x=sympy.Symbol('x') y=x*sympy.atan(x)*sympy.ln(sympy.exp(1+x**2)) dx=sympy.N(sympy.integrate(y,x)) print(dx)没有输出怎么改

import sympy from scipy.integrate import quad y=x*sympy.atan(x)*sympy.ln(sympy.exp(1+x**2)) result,error=quad(y,0,1) print(result)出错怎么办

sympy.simplify函数详解

sympy.core.relational.equality转化为方程

class 'sympy.core.numbers.Float'如何进行运算

最新资源

import sympy x=sympy.Symbol('x') y=xsympy.atan(x)sympy.ln(sympy.exp(1+x**2)) dx=sympy.N(sympy.integrate(y,x)) print(dx)没有输出怎么改

import sympy from scipy.integrate import quad y=xsympy.atan(x)sympy.ln(sympy.exp(1+x**2)) result,error=quad(y,0,1) print(result)出错怎么办