Sympy 0.7.6.1官方教程：数学符号计算全面指南

5星 · 超过95%的资源需积分: 9 115 浏览量更新于2024-07-21 收藏 12.35MB PDF 举报

Sympy reference release-0.7.6.1 是 SymPy，一个强大的Python数学符号计算库的官方文档，旨在帮助用户理解和使用这个工具进行复杂的数学运算、符号逻辑操作以及解决各种数学问题。该版本发布于2015年9月3日，包含了详细的安装指南、教程、常见问题和陷阱，以及用户指南和模块参考。 **1. 安装** 文档首先介绍了几种安装方法，包括从源代码编译（适用于高级用户）、使用Git克隆仓库，以及通过Anaconda包管理器安装。这部分内容对于初次接触SymPy的新手非常重要，确保了他们可以顺利安装并启动使用。 **2. SymPy教程** - **Preliminaries**：简要介绍SymPy的基本概念和环境设置。 - **Introduction**：对SymPy的功能进行概述，展示如何创建和处理符号表达式。 - **Gotchas**：列出了一些可能遇到的问题和陷阱，如误用等于号、变量定义和符号表达式的使用规范。 - **Basic Operations**：涵盖了基本的数学运算，如代数、指数和对数等。 - **Printing**：讲解如何优雅地呈现SymPy的计算结果。 - **Simplification**：演示如何简化复杂的数学表达式。 - **Calculus**：介绍了微积分功能，如求导、积分和极限。 - **Solvers**：展示了如何使用SymPy求解方程、不等式和其他数学问题的解。 - **Matrices**：矩阵操作和线性代数的支持。 - **Advanced Expression Manipulation**：深入探讨更复杂的表达式处理技巧。 **3. Gotchas and Pitfalls** 这部分专门针对可能遇到的困难和误解，例如理解SymPy中符号行为的细节，如何在内部获取帮助，以及如何正确处理特殊符号和函数。 **4. SymPy用户指南** - **Introduction**：对用户指南的介绍，强调学习路径和资源。 - **Learning SymPy**：提供了学习策略和推荐的学习资源，帮助用户逐步掌握SymPy。 - **SymPy's Architecture**：解释SymPy的设计和组织结构，有助于理解其内部工作原理。 - **Contributing**：鼓励用户参与项目，贡献代码和文档。 **5. SymPy模块参考** 文档详细列出了核心模块（如基本运算、函数、几何等）的使用方法，以及诸如组合学、数论、密码学、数值评估和计算等扩展模块，方便用户查找特定功能的具体用法。 SymPy reference release-0.7.6.1是一个全面的指南，适合从零开始学习SymPy的初学者和进阶用户，无论是在进行符号计算、解决数学问题，还是了解其背后的理论和技术，都能在其中找到所需的信息。

SymPy Documentation, Release 0.7.6.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ﬃcult 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 0.7.6.1

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:

x = symbols(’x’)

expr = x + 1

x = 2

print(expr)

2.3. Gotchas 11

SymPy Documentation, Release 0.7.6.1

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)

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

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

2.3. Gotchas 13

SymPy Documentation, Release 0.7.6.1

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

This sort of operator magic happens automatically behind the scenes, and you rarely need to

even know that it is happening. However, there is one exception. Whenever you combine a

SymPy object and a SymPy object, or a SymPy object and a Python object, you get a SymPy

object, but whenever you combine two Python objects, SymPy never comes into play, and so

you get a Python object.

>>> type(Integer(1) + 1)

>>> type(1 + 1)

<... ’int’>

This is usually not a big deal. Python ints work much the same as SymPy Integers, but there

is one important exception: division. In SymPy, the division of two Integers gives a Rational:

>>> Integer(1)/Integer(3)

1/3

>>> type(Integer(1)/Integer(3))

But in Python

represents either integer division or ﬂoating point division, depending on

whether you are in Python 2 or Python 3, and depending on whether or not you have run from

future import division:

>>> from __future__ import division

>>> 1/2

0.5

To avoid this, we can construct the rational object explicitly

>>> Rational(1, 2)

1/2

This problem also comes up whenever we have a larger symbolic expression with int/int in

it. For example:

>>> x + 1/2

x + 0.5

This happens because Python ﬁrst evaluates 1/2 into 0.5, and then that is cast into a SymPy

type when it is added to x. Again, we can get around this by explicitly creating a Rational:

>>> x + Rational(1, 2)

x + 1/2

There are several tips on avoiding this situation in the Gotchas and Pitfalls (page 61) docu-

ment.

2.3.4 Further Reading

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

14 Chapter 2. SymPy Tutorial

剩余1994页未读，继续阅读

「已注销」

粉丝: 45
资源: 59

Sympy 0.7.6.1官方教程：数学符号计算全面指南

lcapy-0.61.0-py3-none-any.whl：PyPI官方发布的Python库下载

Python库giacpy-0.5.4.post1下载及解压指南

SymPy 0.12.0-dev0 数学代数工具包指南

sympy-0.7.6.1Python数学符号计算库

sympy-0.7.4.1.tar.gz

sympy-0.7.6-2.el7.noarch.rpm

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

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

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

sympy-examples-0.7.6-2.el7.noarch.rpm

最新资源