术语表¶

本页面是SymPy文档中使用的各种术语的词汇表。此词汇表主要针对SymPy特有的术语。对于更通用的Python术语，请参考Python词汇表。数学术语仅在此处包含它们在SymPy中具有特定含义的情况。对于一般的数学定义，请参考其他资源，如维基百科或MathWorld，以及特定SymPy函数文档中的参考资料。

原函数¶

一个函数 \(f(x)\) 关于 \(x\) 的原函数是这样一个函数 \(F(x)\)，使得 \(\frac{d}{dx}F(x) = f(x)\)。它有时也被称为 \(f(x)\) 的“不定积分”，并写作 \(\int f(x)\,dx\)。在 SymPy 中，原函数可以通过 integrate() 计算。注意，一些来源称其为 \(f(x)\) 的“原语”，但这种术语在 SymPy 中不被使用，因为它不像“原函数”那样被广泛使用，并且在数学和 SymPy 中，“原语”有其他含义。

args¶

SymPy 表达式的 args 属性是一个元组，包含了用于创建它的顶级子表达式。它们是用于创建表达式的类的参数。任何表达式的参数都可以通过 .args 属性获得。例如，(1 + x*y).args 是 (1, x*y)，因为它等于 Add(1, x*y)。args 与 func 一起完全定义了一个表达式。总是可以通过重复使用 .args 来遍历表达式树并提取任何 SymPy 表达式的子表达式。每个 SymPy 表达式都可以通过 func 和 args 完全重建，也就是说，对于任何 SymPy 表达式 expr，expr.func(*expr.args) == expr 总是成立的。表达式的 args 可能是空元组 ()，这意味着表达式是一个原子。

假设¶

假设是一组对符号或表达式的谓词，定义了它可以取的可能值的集合。一些假设的例子是 positive、real 和 integer。假设在逻辑上是相互关联的，例如，integer 的假设自动意味着 real。假设使用三值逻辑系统，其中谓词要么是 True、False 或 None。

假设可以是假设或查询。例如，符号 x 可以通过定义为 x = symbols('x', positive=True) 来假设为正。然后可以对包含此符号的表达式进行查询假设，例如 (x + 1).is_real，在这种情况下将返回 True。

如果没有对符号做出假设，那么默认情况下，符号被假设为一般的复数。设置假设是重要的，因为某些简化只在受限的定义域内才是数学上正确的，例如，\(\sqrt{x^2} = x\) 对于一般的复数 \(x\) 并不成立，但当 \(x\) 为正数时成立。SymPy 函数不会对表达式执行操作，除非该操作对于其假设允许的所有值都成立。

SymPy 有两个独立的假设系统，它们彼此密切相关。第一个系统有时被称为“旧假设”，因为它更早，假设是在符号对象上进行的，并通过 is_* 属性查询。第二个系统有时被称为“新假设”，假设是通过单独的谓词对象（如 Q.positive）进行的，并使用 ask() 函数进行查询。新的假设系统能够支持更复杂的查询，但也不如旧系统那样成熟。目前，大多数 SymPy 用户应该更喜欢旧的假设系统。

有关假设的更多详细信息，请参阅假设指南。

原子¶

一个 atom 是一个其参数为空元组 () 的表达式。原子是表达式树的叶子。例如，如果一个函数使用递归来遍历表达式树，使用 args，那么原子表达式将是递归的基本情况。

请注意，类 Atom 有时用作原子表达式的基类，但这并不是原子表达式必须继承此类。一个表达式成为原子的唯一要求是其 args 为空。

自动简化¶

自动简化 指的是在类构造函数内部自动发生的任何简化。例如，在 Add 构造函数中，x + x 会自动简化为 2*x。与手动简化不同，自动简化只能通过设置 evaluate=False（参见未求值）来禁用。自动简化通常是为了使表达式规范化。不鼓励过度自动简化，因为它使得在不使用 evaluate=False 等技巧的情况下无法表示表达式的非简化形式，并且在类构造函数中进行这种操作通常成本较高。因此，通常更倾向于手动简化/规范化。

Basic¶

Basic 是所有 SymPy 表达式的超类。它定义了 SymPy 表达式所需的基本方法，例如 args、func、equality、immutability，以及一些有用的表达式操作函数，如 substitution。大多数 SymPy 类将继承一个更具体的 Basic 子类，如 Boolean、Expr、Function 或 Matrix。一个不是 Basic 实例的对象通常不能在 SymPy 函数中使用，除非它可以通过 sympify() 转换为一个 Basic 实例。

Boolean¶

Boolean 是 logic 模块中类的基类。Boolean 实例表示布尔代数中的逻辑谓词，可以被认为是具有“真”或“假”值的元素（注意，Boolean 对象不使用假设中使用的三值逻辑）。

绑定符号¶

表达式中的符号如果是绑定的，那么它就不是自由符号。绑定符号可以在任何地方被新的符号替换，并且结果表达式在数学上仍然是等价的。绑定符号的例子包括定积分中的积分变量和 Subs 中的替换变量。绑定符号有时由哑元符号表示，但它们并不总是 Dummy 对象，而 Dummy 对象也不总是绑定符号。

标准形式¶

规范化¶

通常，表达式可以用多种数学上等价的方式书写。标准形式 是一种书写表达式的单一方式，所有等价的表达式都可以转换为这种形式。将表达式转换为标准形式称为 标准化。通常，标准形式是唯一的，并且具有使其更易于处理的特性。例如，用于有理函数的一种常见标准形式是 \(\frac{p}{q}\)，其中 \(p\) 和 \(q\) 是展开的多项式，没有公因子。

代码生成¶

代码生成 指的是将 SymPy 表达式转换为某种语言或库的代码的过程，以便可以对其进行数值评估。SymPy 支持对数十种语言和库进行代码生成，包括 C、C++、Fortran 和 NumPy。

核心¶

The core 是包含所有 SymPy 对象使用的重要功能的子模块。这包括 Basic 和 Expr 基类、Add、Mul 和 Pow 等类，以及 assumptions。

虚拟¶

一个 dummy 符号是一个自动不等于任何其他 dummy 符号（除了它自己）的符号，即使它们有相同的名字。当一个函数需要返回一个带有新符号的表达式时，使用 dummy 符号，以避免它意外地与同名的符号冲突。可以使用 Dummy 创建 dummy 符号。

方程¶

一个方程是一个表达式，它包含一个等号 \(=\) 。在 SymPy 中，方程使用 Eq 类表示。方程不是通过 == 运算符创建的。== 运算符对两个表达式进行结构相等性检查，并总是返回 True 或 False。相比之下，一个符号方程可能是未求值的。由于方程在数学上表示一个真值或假值的谓词，因此它们被视为布尔值。

_eval_*¶

在 Basic 和 Expr 上的各种方法可以通过使用特殊的 _eval_* 方法在子类上定义。例如，一个对象可以通过定义 _eval_derivative 方法来定义它将如何被 diff() 函数处理。使用的 _eval_* 方法代替了覆盖方法本身，以便基类上定义的方法可以在分派到 _eval_* 方法之前进行预处理。

evalf¶

evalf 是存在于每个 Expr 对象上的方法，它将其评估为浮点数值，或者如果表达式包含符号，则将表达式的常数部分转换为数值。.n() 方法和 N() 函数都是 evalf 的简写。“evalf”代表“评估浮点数”。evalf 在底层使用 mpmath 来评估表达式到任意精度。

评估¶

Evaluate 可以指：

将表达式转换为数值的过程（参见 evalf）。
在创建表达式时发生的自动简化过程（参见未求值）。
在表达式中用数值或其他表达式替换一个或多个符号的过程，使用替换。

Expr¶

Expr 是所有代数 SymPy 表达式的超类。它本身是 Basic 的子类。可以出现在 Add、Mul 或 Pow 中的 SymPy 表达式应该是 Expr 的子类。并非所有 SymPy 类都是 Expr 的子类，例如，Boolean 对象是 Basic 但不是 Expr，因为布尔表达式在 Add 或 Mul 等类中没有数学意义。

表达式¶

任何 SymPy 对象，即 Basic 的任何实例，都可以称为 表达式。有时，术语“表达式”专指 Expr 对象，这些是代数表达式。表达式不应与方程混淆，后者是表示数学等式的特定类型的表达式。

表达式树¶

一个 表达式树 是一个树的表达式。每个表达式都是由较小的表达式组成的树。表达式树的节点是表达式，每个节点的子节点是构成该表达式的直接子表达式。或者，可以将表达式树视为一个树，其中非叶节点是函数，叶节点是原子。一个表达式树的示例在教程中展示。任何 SymPy 表达式的表达式树都可以通过递归参数获得。请注意，由于 SymPy 表达式是不可变的，并且严格通过结构相等性进行处理，因此也可以将表达式树视为 DAG ，其中相同的子表达式在图中只表示一次。

自由符号¶

表达式中的符号是自由的，如果该表达式在数学上依赖于该符号的值。也就是说，如果该符号被替换为一个新的符号，结果将是一个不同的表达式。不是自由的符号是绑定的。表达式的自由符号可以通过 free_symbols 属性访问。

func¶

func 属性是一个表达式的函数，可以通过 expr.func 获取。这通常与 type(expr) 相同，但在某些情况下可能不同，因此在使用参数重建表达式时，应优先使用 expr.func 而不是 type(expr)。每个 SymPy 表达式都可以通过 func 和 args 精确重建，也就是说，对于任何 SymPy 表达式 expr，expr.func(*expr.args) == expr 将始终为真。

函数¶

Function 可能指的是：

数学函数，即从定义域映射到值域的东西。有时，包含符号的表达式被通俗地称为“函数”，因为可以使用替换将符号替换为值，求值表达式。这种用法是通俗的，因为必须使用 subs 方法来完成此操作，而不是典型的 Python 函数调用语法，并且因为它没有具体说明表达式是关于哪些变量的函数，因此通常应优先使用“表达式”一词，除非某物实际上是一个函数。表达式可以转换为可以使用 Python f(x) 语法调用的函数对象，使用 Lambda。
SymPy 函数类的一个实例。
一个 Python 函数，即使用 def 关键字定义的函数。Python 函数不是符号，因为它们必须总是返回一个值，因此不能是未求值的。

Function (类)¶

Function 是 SymPy 中符号函数的基础类。这包括常见的函数如 sin() 和 exp()，特殊函数如 zeta() 和 hyper()，以及积分函数如 primepi() 和 divisor_sigma()。函数类总是符号的，这意味着当传递一个符号时，它们通常保持未求值状态，比如 f(x)。并非每个符号表达式类都是 Function 的子类，例如，核心类如 Add 和 Mul 就不是 Function 的子类。

Function 也可以用来创建一个未定义的函数，通过传递一个字符串名称给函数，例如 Function('f')。

并非SymPy中的每个函数都是符号 Function 类；有些只是始终返回值的Python函数。例如，大多数简化函数如 simplify() 不能被符号表示。

不可变¶

在Python中，如果对象不能就地修改，则它们是不可变的。为了改变一个不可变对象，必须创建一个新的对象。在SymPy中，所有基本对象都是不可变的。这意味着所有对表达式进行操作的函数都将返回一个新的表达式，并保持原始表达式不变。对表达式执行操作永远不会改变引用该表达式的其他对象或表达式。这也意味着任何两个相等的对象是完全可互换的，并且可以被认为是同一个对象，即使它们恰好是内存中的两个不同对象。不可变性使得维护代码的思维模型更容易，因为没有隐藏的状态。SymPy对象的不可变性还意味着它们是可哈希的，这使得它们可以用作字典键。

交互式¶

Interactive 使用指的是在交互式 REPL 环境中使用 SymPy，例如 Python 提示符、isympy、IPython 或 Jupyter notebook。当交互式使用 SymPy 时，所有命令都是由用户实时输入的，所有中间结果都会显示。Interactive 使用与 programmatic 使用形成对比，后者是将代码写在文件中，该文件可以作为脚本执行，或者是更大 Python 库的一部分。一些 SymPy 惯用法仅推荐用于交互式使用，并且在程序化使用时被视为反模式。例如，运行 from sympy import * 在交互式使用 SymPy 时很方便，但在程序化使用时通常不推荐，此时更倾向于使用 import sympy 显式导入名称。

is_*¶

在 SymPy 中，以 is_ 开头且使用小写名称的属性会查询该对象上的给定假设（注意：有少数属性是此规则的例外，因为它们不使用假设系统，参见假设指南）。例如，x.is_integer 会查询 x 上的 integer 假设。使用大写名称的 is_* 属性会测试对象是否为给定类的实例。有时，小写和大写属性会使用相同的名称，但它们是不同的东西。例如，x.is_Integer 仅在 x 是 Integer 的实例时为 True，而 x.is_integer 在 x 在假设系统中为 integer 时为 True，例如 x = symbols('x', integer=True)。一般来说，不推荐使用 is_Capitalized 属性。它们的存在是为了历史原因，但它们是不必要的，因为同样的事情可以通过 isinstance() 实现。另见 Number。

isympy¶

isympy 是 SymPy 附带的一个命令，它启动一个命令行上的交互式会话，其中所有 SymPy 名称已导入并且打印功能已启用。默认情况下，当安装了 IPython 时，它使用 IPython。

种类¶

SymPy 对象的 kind 表示它代表哪种类型的数学对象。对象的 kind 可以通过 kind 属性访问。示例 kind 包括 NumberKind，表示复数，MatrixKind，表示某种其他 kind 的矩阵，以及 BooleanKind，表示布尔谓词。SymPy 对象的 kind 与其 Python 类型不同，因为有时单个 Python 类型可能表示许多不同种类的对象。例如，Matrix 可以是复数矩阵或来自其他值环的对象矩阵。有关 SymPy 中 kind 的更多详细信息，请参阅 SymPy 对象的分类页面。

lamda¶

“Lamda” 只是希腊字母 “lambda” 的另一种拼写。在 SymPy 中有时会使用它，因为 lambda 是 Python 中的保留关键字，所以代表 λ 的符号必须用其他名称命名。

lambdify()¶

lambdify() 是一个函数，它将 SymPy 表达式转换为可以进行数值计算的 Python 函数，通常使用数值库，如 NumPy。

矩阵¶

Matrix 指的是 SymPy 用来表示矩阵的类集合。SymPy 有多个内部类来表示矩阵，取决于矩阵是否是符号的（MatrixExpr）或显式的，可变的或不可变的，密集的或稀疏的，以及底层元素的类型，但这些通常都简称为 “Matrix”。

mpmath¶

mpmath 是一个用于任意精度数值计算的纯 Python 库。它是 SymPy 的硬依赖。mpmath 能够计算数值函数到任意给定的位数。每当 SymPy 对表达式进行数值评估时，如使用 evalf，mpmath 都在幕后使用。

数值¶

一个数值表示或算法是直接对数值输入进行操作的算法。与之相对的是符号表示或算法，它可以处理未求值形式的对象。通常，数值算法与符号算法有很大不同。例如，数值求解常微分方程（ODE）通常意味着使用 Runge–Kutta 等算法来评估 ODE，以在给定初始条件下找到一组数值点，而符号求解 ODE（如使用 SymPy 的 dsolve()）则意味着对 ODE 进行数学操作，以生成一个表示解的符号方程。符号 ODE 解可能包括可以表示任何数值的符号常数。数值算法通常围绕浮点数引起的问题进行设计，如精度损失和数值稳定性，而符号算法不关心这些问题，因为它们精确地计算事物。

除了 SymPy 之外的大多数科学库，如 NumPy 或 SciPy，都是严格数值的，这意味着这些库中的函数只能对特定的数值输入进行操作。它们不能处理 SymPy 表达式，因为它们的算法不是为处理符号输入而设计的。SymPy 专注于符号函数，将纯数值代码留给其他工具如 NumPy。然而，SymPy 确实通过代码生成和 lambdify() 等工具与数值库进行接口。

数字¶

Number 在 SymPy 中可以指代两件事：

类 Number 是显式数字（Integer、Rational 和 Float）的基类。像 pi 这样的符号数值常量不是 Number 的实例。
小写的“number”，如 is_number 属性中所指，指的是任何可以求值为显式 Number 的表达式。这包括像 pi 这样的符号常量。注意，is_number 不是假设系统的一部分。

这种区分对于 is_Number 和 is_number 属性很重要。x.is_Number 将检查 x 是否是 Number 类的实例。

oo¶

oo 是代表正无穷大的 SymPy 对象。它以这种方式拼写，即两个小写字母 O，因为它类似于符号 \(\infty\) 并且易于输入。另请参阅 zoo。

多边形¶

polys 指的是 sympy.polys 子模块，该模块实现了多项式操作的基本数据结构和算法。多项式是 SymPy 的关键部分（尽管通常不被认为是核心的一部分），因为许多基本的符号操作可以表示为多项式上的操作。SymPy 中的许多算法在底层使用了多项式。例如，factor() 是围绕多项式因式分解算法实现的包装器。polys 中的类使用高效的数据结构实现，并且不像 SymPy 中的其他类那样是 Basic 的子类。

打印¶

打印指的是将一个表达式转换为可以在屏幕上查看的形式的行为。打印也常用于指代代码生成。SymPy 有几个打印机，它们使用不同的格式表示表达式。一些更常见的打印机是字符串打印机 (str())、漂亮打印机 (pprint())、LaTeX 打印机 (latex()) 和代码打印机。

关系型¶

一个 关系式 是一个表达式，它是一个符号等式（如 \(a=b\)），或是一个符号不等式，如“小于”（\(a<b\)）。等式（\(=\)）和非等式（\( eq\)）关系式分别由 Eq 和 Ne 创建。例如，Eq(x, 0) 表示 \(x=0\)。这些应该用来代替 == 或 !=，因为这些用于结构而不是符号等式。不等式关系式可以直接使用 <、<=、> 和 >= 创建，如 x < 0。

S¶

SymPy 中的 S 对象有两个用途：

它持有所有单例类作为属性。SymPy 中的一些特殊类是单例化的，这意味着它们总是有且仅有一个实例。这是一种优化，允许节省内存。例如，Integer(0) 的实例只有一个，可以通过 S.Zero 访问。
它作为 sympify() 的简写，即 S(a) 等同于 sympify(a)。这在将整数转换为表达式中的 SymPy 整数时很有用，以避免除以 Python 整数（参见教程的陷阱部分）。

简化¶

简化（不要与 sympify 混淆）指的是将一个表达式转换为另一个在数学上等价但某种程度上“更简单”的表达式的过程。形容词“简单”实际上并没有很好的定义。什么算作更简单取决于具体的用例和个人审美。

SymPy 函数 simplify() 启发式地尝试各种简化算法，试图找到一个表达式的“更简单”形式。如果你对“简化”没有特别的要求，它可能是一个不错的选择。但如果你对想要应用的简化类型有明确的想法，通常使用一个或多个有针对性的简化函数会更好，这些函数对表达式应用非常具体的数学操作。

解决¶

求解器¶

要求解一个方程或方程组，意味着找到一组表达式，使得当给定的符号被代入时，方程（组）成立。例如，关于\(x\)的方程\(x^2 = 1\)的解是集合\(\{-1, 1\}\)。SymPy可以使用不同的求解器函数来求解不同类型的方程。例如，代数方程可以用solve()求解，微分方程可以用dsolve()求解，等等。

SymPy 通常使用“solve”和“solvers”来表示在这个意义上的方程求解。它不是在“解决问题”的意义上使用的。例如，人们通常更倾向于说“计算一个积分”或“求值一个积分”，而不是“求解一个积分”，以指代使用函数 integrate() 进行的符号积分。

结构相等性¶

如果两个 SymPy 对象在表达式上是相等的，即它们具有相同的表达式树，那么它们就是 结构上相等的。由于所有 SymPy 表达式都是不可变的，因此两个结构上相等的表达式被 SymPy 视为相同。结构上的相等性可以通过 == 运算符来检查，该运算符总是返回 True 或 False。符号相等性可以使用 Eq 来表示。

通常，如果两个表达式是同一类且（递归地）具有相同的参数，则它们在结构上是相等的。两个表达式可能在数学上是相同的，但在结构上不相等。例如，(x + 1)**2 和 x**2 + 2*x + 1 在数学上是相等的，但它们在结构上不相等，因为第一个是一个 Pow，其参数由一个 Add 和一个 Integer 组成，而第二个是一个 Add，其参数由一个 Pow、一个 Mul 和一个 Integer 组成。

两个表面上不同的表达式如果在自动简化后被规范化为相同的事物，那么它们在结构上是相等的。例如，x + y 和 y + x 在结构上是相等的，因为 Add 构造函数会自动对其参数进行排序，使得它们变得相同。

子表达式¶

一个 子表达式 是一个包含在更大表达式中的表达式。子表达式出现在表达式树的某个位置。对于 Add 和 Mul 项，在确定什么是子表达式时，可以考虑交换律和结合律。例如，x + y 有时可能被视为 x + y + z 的子表达式，尽管 Add(x, y) 的表达式树不是 Add(x, y, z) 的表达式树的直接子节点。

替换¶

替换指的是在一个表达式中用另一个表达式替换符号或子表达式的行为。SymPy 中有不同的方法来进行替换，包括 subs、replace 和 xreplace。这些方法可能有所不同，取决于它们是仅使用严格的结构相等性进行替换，还是在确定子表达式在表达式中出现的位置时利用数学知识。替换是将表达式视为数学函数并在某一点上进行求值的标准方法。

符号¶

数学对象的符号表示是一种在运行时部分或完全未求值的表示。它可能包括命名的符号常量来代替显式的数值。符号表示通常与数值表示相对比。符号表示在数学上是精确的，与通常为了适应浮点值而四舍五入的数值表示形成对比。表示数学对象的符号表达式可能了解这些对象的数学属性，并能够根据这些属性简化为等价的符号表达式。SymPy 的目标是表示和操作表示各种数学对象的符号表达式。

一些来源使用“解析解”或“闭式解”来指代“符号”的概念，但这些术语在SymPy中并不使用。如果在SymPy中使用，“解析”将指代解析函数的性质，而在SymPy中solve仅指某种类型的符号操作。在SymPy中，“闭式解”通常指的是该术语的数学含义，而“符号”通常指的是一个数学概念如何实现的实现细节，并与同一数学概念的数值实现形成对比。

Symbol¶

Symbol 是符号对象的类。符号表示表达式中的单个数学变量。Symbol 类是 Expr 的子类，并且是原子。Symbol 包含一个名称，该名称可以是任何字符串，以及假设。符号通常通过 Symbol 构造函数或 symbols() 函数定义。具有相同名称和假设的两个符号被认为是相等的。符号被隐含地假设为相对于彼此独立或恒定。常量、变量和参数都由符号表示。区别通常在于符号在给定 SymPy 函数中的使用方式。

sympify()¶

sympify() （不要与 simplify() 混淆）是一个将非SymPy对象转换为SymPy对象的函数。sympify() 的结果将是 Basic 的一个实例。可以被 sympify 的对象包括原生Python数值类型，如 int 和 float，可以解析为SymPy 表达式的字符串，以及包含 sympifiable 对象的可迭代对象（更多信息请参阅 sympify() 的文档）。

由于所有 SymPy 表达式必须是 Basic 的实例，所有 SymPy 函数和操作都会在其输入上隐式调用 sympify()。例如，x + 1 会隐式调用 sympify(1) 将 Python int 类型的 1 转换为 SymPy Integer。接受 SymPy 表达式的函数通常应在它们的参数上调用 sympify()，以便即使在输入不是 SymPy 类型时也能正常工作。

三值逻辑¶

三值逻辑 是一种具有三个值的逻辑，即 True、False 和 None。它有时也被称为模糊逻辑，尽管这个术语在数学文献中也有不同的含义，因此更倾向于使用“三值逻辑”。True 和 False 的工作方式与通常的两值谓词逻辑相同。None 是一个额外的术语，表示“未知”、“不可计算”或“可能是 True 或 False”（从哲学上讲，这些是不同的概念，但从逻辑上讲，它们的功能完全相同）。None 的语义是，在逻辑操作中，当结果会因将其替换为 True 或 False 而有所不同时，它会吸收其他术语。例如，None OR False 是 None，但 None OR True 是 True，因为无论 None “实际上”代表 True 还是 False，谓词都是 True。在使用通常的 Python 逻辑运算符如 and、or 和 not 处理三值逻辑时必须小心，因为 None 是假的。有关如何使用三值逻辑编码的更多详细信息，请参阅符号和模糊布尔值指南。

三值逻辑被假设系统用来表示未知的假设。例如，如果 x 在其给定的假设下可能为正或负，则 x.is_positive 可能为 None。请注意，由布尔子类定义的谓词逻辑表示标准的二值逻辑，而不是三值逻辑。

未定义函数¶

一个 未定义函数 是一个函数，它没有任何数学属性定义在其上。它总是保持未求值，就像 f(x) 。一个未定义函数可以通过传递函数的字符串名称给 Function 来创建，例如 f = Function('f') 。未定义函数通常在处理 ODEs 时使用。未定义函数也是创建符号的最简单方式，这些符号在数学上依赖于其他符号。例如，如果 f = Function('f') 且 x = Symbol('x') ，那么 SymPy 将知道 f(x) 依赖于 x ，这意味着，例如，导数 diff(f(x), x) 将不会被求值为 0 。

未评估¶

如果禁用了通常在表达式创建时发生的自动简化，则该表达式是 未求值 的。这通常通过设置 evaluate=False、使用 with evaluate(False) 或使用 UnevaluatedExpr 来完成。虽然支持未求值的表达式，但它们有时会导致意外行为，因为这些表达式没有正确地规范化。

术语 未求值 有时也用来表示一个表达式在参数为符号时不会求值为一个特定值。

动物园¶

*{class}`zoo <sympy.core.numbers.ComplexInfinity>`* 表示复无穷大，即黎曼球面的北极。它这样拼写的原因是它是“z-oo”，其中“z”是通常用于复变量的符号，而 ``oo`` 是 SymPy 用于实正无穷大的符号。