级数展开¶

限制¶

该模块的主要目的是计算极限。

sympy.series.limits.limit(e, z, z0, dir='+')[源代码][源代码]¶

计算 e(z) 在点 z0 处的极限。

参数:

e表达式，其极限将被求取
z表示极限中变量的符号。: 其他符号被视为常量。不支持多元极限。
z0 : z 趋向的值。可以是任何表达式，朝向的值: 包括 oo 和 -oo。
目录字符串，可选（默认值：“+”）: 如果 dir="+-"，则极限是双向的；如果 dir="+"，则从右侧（z->z0+）；如果 dir="-"，则从左侧（z->z0-）。对于无穷大的 z0``（即 ``oo 或 -oo），dir 参数由无穷大的方向决定（即，对于 oo，dir="-"）。

参见

limit_seq: 返回序列的限制。

注释

首先，我们尝试一些针对常见情况（如“x”、“1/x”、“x**2”及类似情况）的启发式方法，以确保快速处理。对于所有其他情况，我们使用Gruntz算法（参见gruntz()函数）。

示例

>>> from sympy import limit, sin, oo
>>> from sympy.abc import x
>>> limit(sin(x)/x, x, 0)
1
>>> limit(1/x, x, 0) # default dir='+'
oo
>>> limit(1/x, x, 0, dir="-")
-oo
>>> limit(1/x, x, 0, dir='+-')
zoo
>>> limit(1/x, x, oo)
0

class sympy.series.limits.Limit(e, z, z0, dir='+')[源代码][源代码]¶

表示一个未评估的极限。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_free_symbols: 类似于 free_symbols，但仅在自由符号包含在表达式节点中时返回它们。
free_symbols: 从自身的原子中返回那些自由符号。
func: 表达式中的顶级函数。
is_algebraic
is_antihermitian
is_commutative
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_complex
is_composite
is_even
is_extended_negative
is_extended_nonnegative
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_extended_real
is_finite
is_hermitian
is_imaginary
is_infinite
is_integer
is_irrational
is_negative
is_noninteger
is_nonnegative
is_nonpositive
is_nonzero
is_number: 如果 self 没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。
is_odd
is_polar
is_positive
is_prime
is_rational
is_real
is_transcendental
is_zero

方法

`apart`([x])	请参阅 sympy.polys 中的 apart 函数。
`args_cnc`([cset, warn, split_1])	返回 [交换因子, 非交换因子] 的自身。
`as_coeff_Add`([rational])	高效地提取求和的系数。
`as_coeff_Mul`([rational])	高效地提取乘积的系数。
`as_coeff_add`(*deps)	返回元组 (c, args)，其中 self 被写成一个 Add，`a`。
`as_coeff_exponent`(x)	`cx*e -> c,e` 其中 x 可以是任何符号表达式。
`as_coeff_mul`(deps, *kwargs)	返回元组 (c, args)，其中 self 被写成一个 Mul，`m`。
`as_coefficient`(expr)	提取给定表达式中的符号系数。
`as_coefficients_dict`(*syms)	返回一个字典，将术语映射到它们的 Rational 系数。
`as_content_primitive`([radical, clear])	此方法应递归地从所有参数中移除一个 Rational，并返回该内容和新的 self（原始类型）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`as_expr`(*gens)	将多项式转换为 SymPy 表达式。
`as_independent`(deps, *hint)	将 Mul 或 Add 的大部分天真分离为不依赖于 deps 的参数。
`as_leading_term`(*symbols[, logx, cdir])	返回自身级数展开的主导（非零）项。
`as_numer_denom`()	返回一个表达式的分子和分母。
`as_ordered_factors`([order])	返回有序因子列表（如果是 Mul），否则返回 [self]。
`as_ordered_terms`([order, data])	将表达式转换为有序的项列表。
`as_poly`(gens, *args)	将 `self` 转换为多项式，或返回 `None`。
`as_powers_dict`()	将自身作为一个因子的字典返回，每个因子都被视为一个幂。
`as_real_imag`([deep])	对 'self' 执行复杂的扩展，并返回一个包含收集到的实部和虚部的元组。
`as_terms`()	将一个表达式转换为项的列表。
`aseries`([x, n, bound, hir])	自变量的渐近级数展开
`atoms`(*types)	返回构成当前对象的原子。
`cancel`(gens, *args)	参见 sympy.polys 中的取消函数
`class_key`()	类的好顺序。
`coeff`(x[, n, right, _first])	返回包含 `x**n` 的项中的系数。
`collect`(syms[, func, evaluate, exact, ...])	请参阅 sympy.simplify 中的 collect 函数。
`combsimp`()	请参阅 sympy.simplify 中的 combsimp 函数。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`compute_leading_term`(x[, logx])	已弃用的函数，用于计算级数的首项。
`conjugate`()	返回 'self' 的复数共轭。
`could_extract_minus_sign`()	如果 self 以 -1 作为前导因子，或在求和中有比正号更多的负号，则返回 True，否则返回 False。
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])
`doit`(**hints)	计算极限。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`equals`(other[, failing_expression])	如果 self == other 则返回 True，如果不相等则返回 False，或者返回 None。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`expand`([deep, modulus, power_base, ...])	使用提示扩展表达式。
`extract_additively`(c)	如果可以从自身减去 c 并且使所有匹配的系数趋向于零，则返回 self - c，否则返回 None。
`extract_branch_factor`([allow_half])	尝试以 `exp_polar(2piIn)z` 的方式优雅地表达自身。
`extract_multiplicatively`(c)	如果无法以一种良好的方式将 self 表示为 c * something，即保留 self 参数的属性，则返回 None。
`factor`(gens, *args)	参见 sympy.polys.polytools 中的 factor() 函数
`find`(query[, group])	查找所有匹配查询的子表达式。
`fourier_series`([limits])	计算自身的傅里叶正弦/余弦级数。
`fps`([x, x0, dir, hyper, order, rational, full])	计算自身的形式幂级数。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`gammasimp`()	参见 sympy.simplify 中的 gammasimp 函数
`getO`()	如果有加法 O(..) 符号，则返回该符号，否则返回 None。
`getn`()	返回表达式的顺序。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`integrate`(args, *kwargs)	请参阅 sympy.integrals 中的 integrate 函数。
`invert`(g, gens, *args)	返回 `self` 对 `g` 的乘法逆元，其中 self``（和 ``g）可以是符号表达式。
`is_algebraic_expr`(*syms)	此测试给定的表达式是否在给定的符号 syms 中是代数的。
`is_constant`(wrt, *flags)	如果 self 是常量则返回 True，如果不是则返回 False，如果无法明确确定常量性则返回 None。
`is_meromorphic`(x, a)	此测试表达式是否作为给定符号 `x` 的函数在点 `a` 处是亚纯的。
`is_polynomial`(*syms)	如果 self 是 syms 中的多项式，则返回 True，否则返回 False。
`is_rational_function`(*syms)	测试函数是否是给定符号 syms 中的两个多项式的比率。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`leadterm`(x[, logx, cdir])	返回前导项 ax*b 作为元组 (a, b)。
`limit`(x, xlim[, dir])	计算极限 x->xlim。
`lseries`([x, x0, dir, logx, cdir])	用于生成序列项的迭代器的包装器。
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`normal`()	返回表达式为分数形式。
`nseries`([x, x0, n, dir, logx, cdir])	如果假设允许，则包装到 _eval_nseries，否则包装到 series。
`nsimplify`([constants, tolerance, full])	参见 sympy.simplify 中的 nsimplify 函数
`powsimp`(args, *kwargs)	请参阅 sympy.simplify 中的 powsimp 函数
`primitive`()	返回可以从自身每个项中非递归提取的正有理数（即，将自身视为一个加法）。
`radsimp`(**kwargs)	参见 sympy.simplify 中的 radsimp 函数
`ratsimp`()	参见 sympy.simplify 中的 ratsimp 函数。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`removeO`()	如果存在，移除加性的 O(..) 符号
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`round`([n])	返回 x 四舍五入到给定的十进制位数。
`separate`([deep, force])	参见 sympy.simplify 中的单独函数
`series`([x, x0, n, dir, logx, cdir])	在 `x = x0` 附近对 "self" 进行级数展开，当 n=None 时逐项给出级数项（即惰性级数），否则当 n != None 时一次性给出所有项。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`sort_key`([order])
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`taylor_term`(n, x, *previous_terms)	泰勒项的一般方法。
`together`(args, *kwargs)	请参阅 sympy.polys 中的 together 函数。
`trigsimp`(**args)	参见 sympy.simplify 中的 trigsimp 函数
`xreplace`(rule)	替换表达式中对象的出现。

伴随
as_base_exp
复制
差异
目录
is_hypergeometric
pow_heuristics
转置

示例

>>> from sympy import Limit, sin
>>> from sympy.abc import x
>>> Limit(sin(x)/x, x, 0)
Limit(sin(x)/x, x, 0, dir='+')
>>> Limit(1/x, x, 0, dir="-")
Limit(1/x, x, 0, dir='-')

doit(**hints)[源代码][源代码]¶

计算极限。

参数:

深度bool, 可选 (默认: True): 在取极限之前，调用涉及表达式的 doit 方法。
提示可选的关键字参数: 传递给 doit 方法；仅在 deep 为 True 时使用。

如上所述，用于计算极限的主力函数是 gruntz()，它实现了用于计算极限的 Gruntz 算法。

Gruntz 算法¶

本节解释了用于计算极限的算法基础。大多数情况下，limit() 函数应该能正常工作。然而，记住它的实现方式仍然是有用的，以防出现预期之外的情况。

首先我们定义函数之间的序。假设 \(f(x)\) 和 \(g(x)\) 是两个实值函数，使得 \(\lim_{x \to \infty} f(x) = \infty\)，并且同样地 \(\lim_{x \to \infty} g(x) = \infty\)。我们称 \(f(x)\) 支配 \(g(x)\)，记作 \(f(x) \succ g(x)\)，如果对于所有 \(a, b \in \mathbb{R}_{>0}\)，我们有 \(\lim_{x \to \infty} \frac{f(x)^a}{g(x)^b} = \infty\)。我们还称 \(f(x)\) 和 \(g(x)\) 是 同一可比类，如果既不 \(f(x) \succ g(x)\) 也不 \(g(x) \succ f(x)\)，并将其表示为 \(f(x) \asymp g(x)\)。

注意，每当 \(a, b \in \mathbb{R}_{>0}\) 时，\(a f(x)^b \asymp f(x)\)，我们将利用这一点将 \(\succ\) 的定义扩展到所有在 \(x \to \infty\) 时趋向于 \(0\) 或 \(\pm \infty\) 的函数。因此我们声明 \(f(x) \asymp 1/f(x)\) 和 \(f(x) \asymp -f(x)\)。

展示以下示例很容易：

\(e^x \succ x^m\)
\(e^{x^2} \succ e^{mx}\)
\(e^{e^x} \succ e^{x^m}\)
\(x^m \asymp x^n\)
\(e^{x + \frac{1}{x}} \asymp e^{x + \log{x}} \asymp e^x\).

从上述定义中，可以证明以下性质：

假设 \(\omega\), \(g_1, g_2, \ldots\) 是 \(x\) 的函数，\(\lim_{x \to \infty} \omega = 0\) 且对于所有 \(i\) 有 \(\omega \succ g_i\)。设 \(c_1, c_2, \ldots \in \mathbb{R}\) 且 \(c_1 < c_2 < \cdots\)。

然后 \(\lim_{x \to \infty} \sum_i g_i \omega^{c_i} = \lim_{x \to \infty} g_1 \omega^{c_1}\)。

对于 \(g_1 = g\) 和 \(\omega\) 如上所述，我们也有以下简单结果：

\(\lim_{x \to \infty} g \omega^c = 0\) 对于 \(c > 0\)

\(\lim_{x \to \infty} g \omega^c = \pm \infty\) 对于 \(c < 0\)，其中符号由 \(g\) 的（最终）符号决定

\(\lim_{x \to \infty} g \omega^0 = \lim_{x \to \infty} g\).

使用这些结果可以得出以下计算 \(\lim_{x \to \infty} f(x)\) 的策略：

找到 \(f(x)\) 的 变化最快的子表达式 集合（MRV 集）。也就是说，从 \(f(x)\) 的所有子表达式集合中，找到在关系 \(\succ\) 下最大的元素。
选择一个函数 \(\omega\)，它与 MRV 集中的元素属于同一可比性类，使得 \(\lim_{x \to \infty} \omega = 0\)。
将 \(f(x)\) 展开为 \(\omega\) 的级数，使得上述定理的前提条件得到满足。
应用定理并完成 \(\lim_{x \to \infty} f(x)\) 的计算，可能通过递归处理 \(g_1(x)\) 来实现。

注释¶

这次阐述忽略了许多细节。许多细节在文件 gruntz.py 中有描述，所有内容都可以在 Gruntz 的非常易读的论文中找到。最重要的未解释的点是：

给定 ( f(x) ) 和 ( g(x) )，我们如何确定 ( f(x) succ g(x) )、( g(x) succ f(x) ) 还是 ( g(x) asymp f(x) )？
我们如何找到一个表达式的 MRV 集合？
我们如何计算级数展开？
为什么算法会终止？

如果你感兴趣，一定要看看 Gruntz 论文。

参考¶

sympy.series.gruntz.gruntz(e, z, z0, dir='+')[源代码][源代码]¶: 使用 Gruntz 算法计算 e(z) 在点 z0 处的极限。

sympy.series.gruntz.compare(a, b, x)[源代码][源代码]¶: 返回 “<” 如果 a<b，”=” 如果 a == b，”>” 如果 a>b

sympy.series.gruntz.rewrite(e, Omega, x, wsym)[源代码][源代码]¶

e(x) … Omega 函数 … mrv 集合 wsym … 将用于 w 的符号

返回用 w 和 log(w) 重写的 e。参见 test_rewrite1() 以获取示例和正确结果。

sympy.series.gruntz.build_expression_tree(Omega, rewrites)[源代码][源代码]¶

用于重写的辅助函数。

我们需要对 Omega (mrv 集合) 进行排序，以便在我们替换任何需要重写的表达式之前替换一个表达式:

e1 ---> e2 ---> e3
         \
          -> e4

在这里我们可以做 e1, e2, e3, e4 或者 e1, e2, e4, e3。为此，我们将节点组装成一棵树，并按高度排序。

此函数构建树，重写然后排序节点。

sympy.series.gruntz.mrv_leadterm(e, x)[源代码][源代码]¶: 返回 e 的 (c0, e0)。

sympy.series.gruntz.calculate_series(e, x, logx=None)[源代码][源代码]¶

计算 x 中 e 级数中的至少一项。

这是一个最容易出错的地方，所以它有自己的函数。

sympy.series.gruntz.limitinf(e, x)[源代码][源代码]¶: 当 x 趋向于无穷大时，限制 e(x)。

sympy.series.gruntz.sign(e, x)[源代码][源代码]¶

返回表达式 e(x) 在 x->oo 时的符号。

e >  0 for x sufficiently large ...  1
e == 0 for x sufficiently large ...  0
e <  0 for x sufficiently large ... -1

如果 e 对于任意大的 x 任意多次改变符号（例如 sin(x)），此函数的结果目前是未定义的。

请注意，只有在 e 对于足够大的 x 始终为零时，此函数才会返回零。[如果 e 是常数，当然，这和 e 的符号是一样的。]

sympy.series.gruntz.mrv(e, x)[源代码][源代码]¶: 返回一个包含表达式 ‘e’ 中变化最快的（mrv）子表达式的 SubsSet，并将 e 重写为这些子表达式的形式。

sympy.series.gruntz.mrv_max1(f, g, exps, x)[源代码][源代码]¶: 计算两组表达式 f 和 g 的最大值，它们属于同一可比性类别，即 mrv_max1() 比较（两个元素）f 和 g 并返回集合，该集合在两者的并集中具有更高的可比性类别，如果它们的变异顺序相同。同时返回 exps，并进行适当的替换。

sympy.series.gruntz.mrv_max3(f, expsf, g, expsg, union, expsboth, x)[源代码][源代码]¶: 计算两组表达式 f 和 g 的最大值，它们属于同一可比性类别，即 max() 比较（两个元素）f 和 g 并返回 (f, expsf) [如果 f 较大]，(g, expsg) [如果 g 较大] 或 (union, expsboth) [如果 f, g 属于同一类别]。

class sympy.series.gruntz.SubsSet[源代码][源代码]¶

存储 (expr, dummy) 对，以及如何重写 expr。

方法

`clear`()
`copy`()	创建 SubsSet 的浅拷贝
`do_subs`(e)	用表达式替换变量
`fromkeys`(iterable[, value])	使用可迭代对象中的键创建一个新字典，并将值设置为指定的值。
`get`(key[, default])	如果字典中存在键，则返回键的值，否则返回默认值。
`items`()
`keys`()
`meets`(s2)	判断 self 和 s2 是否具有非空交集
`pop`(key[, default])	如果未找到键，则返回给定的默认值；否则，引发 KeyError。
`popitem`(/)	移除并返回一个 (键, 值) 对作为 2-tuple。
`setdefault`(key[, default])	如果字典中不存在键，则插入键并赋予默认值。
`union`(s2[, exps])	计算 self 和 s2 的并集，调整 exps
`update`([E, ]**F)	如果 E 存在且有 .keys() 方法，则执行： for k in E: D[k] = E[k] 如果 E 存在但没有 .keys() 方法，则执行： for k, v in E: D[k] = v 在任何一种情况下，之后都会执行： for k in F: D[k] = F[k]
`values`()

copy()[源代码][源代码]¶: 创建 SubsSet 的浅拷贝

do_subs(e)[源代码][源代码]¶: 用表达式替换变量

meets(s2)[源代码][源代码]¶: 判断 self 和 s2 是否具有非空交集

union(s2, exps=None)[源代码][源代码]¶: 计算 self 和 s2 的并集，调整 exps

更直观的级数展开¶

这是通过围绕 Basic.series() 创建一个包装器来实现的。这允许使用 series(x*cos(x),x)，这可能比 (x*cos(x)).series(x) 更直观。

示例¶

>>> from sympy import Symbol, cos, series
>>> x = Symbol('x')
>>> series(cos(x),x)
1 - x**2/2 + x**4/24 + O(x**6)

参考¶

sympy.series.series.series(expr, x=None, x0=0, n=6, dir='+')[源代码][源代码]¶

在点 \(x = x0\) 附近展开 expr 的级数。

参数:

表达式表达式: 要展开其级数的表达式。
x符号: 这是要计算的表达式的变量。
x0值: 计算 x 所围绕的值。可以是 -oo 到 oo 之间的任何值。
n值: 要展开的级数项数。
目录字符串，可选: 级数展开可以是双向的。如果 dir="+"，则 (x->x0+)。如果 dir="-"，则 (x->x0-)。对于无穷大的 x0``（``oo 或 -oo），dir 参数由无穷大的方向决定（即，oo 对应 dir="-"）。

返回:

表达式: 关于 x0 的表达式的级数展开

参见

sympy.core.expr.Expr.series: 有关此包装器的完整详细信息，请参阅 Expr.series() 的文档字符串。

示例

>>> from sympy import series, tan, oo
>>> from sympy.abc import x
>>> f = tan(x)
>>> series(f, x, 2, 6, "+")
tan(2) + (1 + tan(2)**2)*(x - 2) + (x - 2)**2*(tan(2)**3 + tan(2)) +
(x - 2)**3*(1/3 + 4*tan(2)**2/3 + tan(2)**4) + (x - 2)**4*(tan(2)**5 +
5*tan(2)**3/3 + 2*tan(2)/3) + (x - 2)**5*(2/15 + 17*tan(2)**2/15 +
2*tan(2)**4 + tan(2)**6) + O((x - 2)**6, (x, 2))

>>> series(f, x, 2, 3, "-")
tan(2) + (2 - x)*(-tan(2)**2 - 1) + (2 - x)**2*(tan(2)**3 + tan(2))
+ O((x - 2)**3, (x, 2))

>>> series(f, x, 2, oo, "+")
Traceback (most recent call last):
...
TypeError: 'Infinity' object cannot be interpreted as an integer

订单条款¶

此模块还实现了自动跟踪扩展顺序的功能。

示例¶

>>> from sympy import Symbol, Order
>>> x = Symbol('x')
>>> Order(x) + x**2
O(x)
>>> Order(x) + 1
1 + O(x)

参考¶

class sympy.series.order.Order(expr, *args, **kwargs)[源代码][源代码]¶

表示某些函数的极限行为。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
表达式
expr_free_symbols: 类似于 free_symbols，但仅在自由符号包含在表达式节点中时返回它们。
free_symbols: 从自身的原子中返回那些自由符号。
func: 表达式中的顶级函数。
is_algebraic
is_antihermitian
is_commutative
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_complex
is_composite
is_even
is_extended_negative
is_extended_nonnegative
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_extended_real
is_finite
is_hermitian
is_imaginary
is_infinite
is_integer
is_irrational
is_negative
is_noninteger
is_nonnegative
is_nonpositive
is_nonzero
is_number: 如果 self 没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。
is_odd
is_polar
is_positive
is_prime
is_rational
is_real
is_transcendental
is_zero
点
变量

方法

`apart`([x])	请参阅 sympy.polys 中的 apart 函数。
`args_cnc`([cset, warn, split_1])	返回 [交换因子, 非交换因子] 的自身。
`as_coeff_Add`([rational])	高效地提取求和的系数。
`as_coeff_Mul`([rational])	高效地提取乘积的系数。
`as_coeff_add`(*deps)	返回元组 (c, args)，其中 self 被写成一个 Add，`a`。
`as_coeff_exponent`(x)	`cx*e -> c,e` 其中 x 可以是任何符号表达式。
`as_coeff_mul`(deps, *kwargs)	返回元组 (c, args)，其中 self 被写成一个 Mul，`m`。
`as_coefficient`(expr)	提取给定表达式中的符号系数。
`as_coefficients_dict`(*syms)	返回一个字典，将术语映射到它们的 Rational 系数。
`as_content_primitive`([radical, clear])	此方法应递归地从所有参数中移除一个 Rational，并返回该内容和新的 self（原始类型）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`as_expr`(*gens)	将多项式转换为 SymPy 表达式。
`as_independent`(deps, *hint)	将 Mul 或 Add 的大部分天真分离为不依赖于 deps 的参数。
`as_leading_term`(*symbols[, logx, cdir])	返回自身级数展开的主导（非零）项。
`as_numer_denom`()	返回一个表达式的分子和分母。
`as_ordered_factors`([order])	返回有序因子列表（如果是 Mul），否则返回 [self]。
`as_ordered_terms`([order, data])	将表达式转换为有序的项列表。
`as_poly`(gens, *args)	将 `self` 转换为多项式，或返回 `None`。
`as_powers_dict`()	将自身作为一个因子的字典返回，每个因子都被视为一个幂。
`as_real_imag`([deep])	对 'self' 执行复杂的扩展，并返回一个包含收集到的实部和虚部的元组。
`as_terms`()	将一个表达式转换为项的列表。
`aseries`([x, n, bound, hir])	自变量的渐近级数展开
`atoms`(*types)	返回构成当前对象的原子。
`cancel`(gens, *args)	参见 sympy.polys 中的取消函数
`class_key`()	类的好顺序。
`coeff`(x[, n, right, _first])	返回包含 `x**n` 的项中的系数。
`collect`(syms[, func, evaluate, exact, ...])	请参阅 sympy.simplify 中的 collect 函数。
`combsimp`()	请参阅 sympy.simplify 中的 combsimp 函数。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`compute_leading_term`(x[, logx])	已弃用的函数，用于计算级数的首项。
`conjugate`()	返回 'self' 的复数共轭。
`contains`(expr)	如果 expr 属于 Order(self.expr, *self.variables)，则返回 True。
`could_extract_minus_sign`()	如果 self 以 -1 作为前导因子，或在求和中有比正号更多的负号，则返回 True，否则返回 False。
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])
`doit`(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`equals`(other[, failing_expression])	如果 self == other 则返回 True，如果不相等则返回 False，或者返回 None。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`expand`([deep, modulus, power_base, ...])	使用提示扩展表达式。
`extract_additively`(c)	如果可以从自身减去 c 并且使所有匹配的系数趋向于零，则返回 self - c，否则返回 None。
`extract_branch_factor`([allow_half])	尝试以 `exp_polar(2piIn)z` 的方式优雅地表达自身。
`extract_multiplicatively`(c)	如果无法以一种良好的方式将 self 表示为 c * something，即保留 self 参数的属性，则返回 None。
`factor`(gens, *args)	参见 sympy.polys.polytools 中的 factor() 函数
`find`(query[, group])	查找所有匹配查询的子表达式。
`fourier_series`([limits])	计算自身的傅里叶正弦/余弦级数。
`fps`([x, x0, dir, hyper, order, rational, full])	计算自身的形式幂级数。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`gammasimp`()	参见 sympy.simplify 中的 gammasimp 函数
`getO`()
`getn`()	返回表达式的顺序。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`integrate`(args, *kwargs)	请参阅 sympy.integrals 中的 integrate 函数。
`invert`(g, gens, *args)	返回 `self` 对 `g` 的乘法逆元，其中 self``（和 ``g）可以是符号表达式。
`is_algebraic_expr`(*syms)	此测试给定的表达式是否在给定的符号 syms 中是代数的。
`is_constant`(wrt, *flags)	如果 self 是常量则返回 True，如果不是则返回 False，如果无法明确确定常量性则返回 None。
`is_meromorphic`(x, a)	此测试表达式是否作为给定符号 `x` 的函数在点 `a` 处是亚纯的。
`is_polynomial`(*syms)	如果 self 是 syms 中的多项式，则返回 True，否则返回 False。
`is_rational_function`(*syms)	测试函数是否是给定符号 syms 中的两个多项式的比率。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`leadterm`(x[, logx, cdir])	返回前导项 ax*b 作为元组 (a, b)。
`limit`(x, xlim[, dir])	计算极限 x->xlim。
`lseries`([x, x0, dir, logx, cdir])	用于生成序列项的迭代器的包装器。
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`normal`()	返回表达式为分数形式。
`nseries`([x, x0, n, dir, logx, cdir])	如果假设允许，则包装到 _eval_nseries，否则包装到 series。
`nsimplify`([constants, tolerance, full])	参见 sympy.simplify 中的 nsimplify 函数
`powsimp`(args, *kwargs)	请参阅 sympy.simplify 中的 powsimp 函数
`primitive`()	返回可以从自身每个项中非递归提取的正有理数（即，将自身视为一个加法）。
`radsimp`(**kwargs)	参见 sympy.simplify 中的 radsimp 函数
`ratsimp`()	参见 sympy.simplify 中的 ratsimp 函数。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`removeO`()
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`round`([n])	返回 x 四舍五入到给定的十进制位数。
`separate`([deep, force])	参见 sympy.simplify 中的单独函数
`series`([x, x0, n, dir, logx, cdir])	在 `x = x0` 附近对 "self" 进行级数展开，当 n=None 时逐项给出级数项（即惰性级数），否则当 n != None 时一次性给出所有项。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`sort_key`([order])
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`taylor_term`(n, x, *previous_terms)	泰勒项的一般方法。
`together`(args, *kwargs)	请参阅 sympy.polys 中的 together 函数。
`trigsimp`(**args)	参见 sympy.simplify 中的 trigsimp 函数
`xreplace`(rule)	替换表达式中对象的出现。

伴随
as_base_exp
as_expr_variables
复制
差异
目录
is_hypergeometric
转置

注释

在 O(f(x), x) 中，表达式 f(x) 被假定具有一个首项。 O(f(x), x) 会自动转换为 O(f(x).as_leading_term(x),x)。

O(expr*f(x), x) 是 O(f(x), x)

O(expr, x) 是 O(1)

O(0, x) 是 0。

多元 O 也被支持：

O(f(x, y), x, y) 被转换为 O(f(x, y).as_leading_term(x,y).as_leading_term(y), x, y)

在多变量情况下，假设关于各个符号的极限是可交换的。

如果没有传递符号，则表达式中的所有符号都将被使用，并且极限点被假定为零。

参考文献

[1]

大O符号

示例

>>> from sympy import O, oo, cos, pi
>>> from sympy.abc import x, y

>>> O(x + x**2)
O(x)
>>> O(x + x**2, (x, 0))
O(x)
>>> O(x + x**2, (x, oo))
O(x**2, (x, oo))

>>> O(1 + x*y)
O(1, x, y)
>>> O(1 + x*y, (x, 0), (y, 0))
O(1, x, y)
>>> O(1 + x*y, (x, oo), (y, oo))
O(x*y, (x, oo), (y, oo))

>>> O(1) in O(1, x)
True
>>> O(1, x) in O(1)
False
>>> O(x) in O(1, x)
True
>>> O(x**2) in O(x)
True

>>> O(x)*x
O(x**2)
>>> O(x) - O(x)
O(x)
>>> O(cos(x))
O(1)
>>> O(cos(x), (x, pi/2))
O(x - pi/2, (x, pi/2))

contains(expr)[源代码][源代码]¶: 如果 expr 属于 Order(self.expr, *self.variables)，则返回 True。如果 self 属于 expr，则返回 False。如果无法确定包含关系（例如当 self 和 expr 具有不同的符号时），则返回 None。

系列加速¶

待办事项

参考¶

sympy.series.acceleration.richardson(A, k, n, N)[源代码][源代码]¶

使用Richardson外推法，利用项A(n), A(n+1), …, A(n+N+1)计算lim k->oo A(k)的近似值。选择N ~= 2*n通常能得到较好的结果。

示例

一个简单的例子是使用极限定义来计算 exp(1)。这个极限收敛得很慢；n = 100 只能产生两位准确数字：

>>> from sympy.abc import n
>>> e = (1 + 1/n)**n
>>> print(round(e.subs(n, 100).evalf(), 10))
2.7048138294

使用11个适当选择的项进行Richardson外推法可以得到一个精确到指定精度的值：

>>> from sympy import E
>>> from sympy.series.acceleration import richardson
>>> print(round(richardson(e, n, 10, 20).evalf(), 10))
2.7182818285
>>> print(round(E.evalf(), 10))
2.7182818285

另一个有用的应用是加速级数的收敛。计算 zeta(2) 级数的 100 项 1/k**2 仅能得到两位有效数字：

>>> from sympy.abc import k, n
>>> from sympy import Sum
>>> A = Sum(k**-2, (k, 1, n))
>>> print(round(A.subs(n, 100).evalf(), 10))
1.6349839002

Richardson 外推法表现要好得多：

>>> from sympy import pi
>>> print(round(richardson(A, n, 10, 20).evalf(), 10))
1.6449340668
>>> print(round(((pi**2)/6).evalf(), 10))     # Exact value
1.6449340668

sympy.series.acceleration.shanks(A, k, n, m=1)[源代码][源代码]¶

使用 n 项 Shanks 变换 S(A)(n) 计算 lim k->oo A(k) 的近似值。对于 m > 1，计算 m 重递归 Shanks 变换 S(S(…S(A)…))(n)。

Shanks 变换对于求和在极点或奇点附近收敛缓慢的泰勒级数非常有用，例如对于 log(2)：

>>> from sympy.abc import k, n
>>> from sympy import Sum, Integer
>>> from sympy.series.acceleration import shanks
>>> A = Sum(Integer(-1)**(k+1) / k, (k, 1, n))
>>> print(round(A.subs(n, 100).doit().evalf(), 10))
0.6881721793
>>> print(round(shanks(A, n, 25).evalf(), 10))
0.6931396564
>>> print(round(shanks(A, n, 25, 5).evalf(), 10))
0.6931471806

正确的值是 0.6931471805599453094172321215。

残基¶

待办事项

参考¶

sympy.series.residues.residue(expr, x, x0)[源代码][源代码]¶

在 x=x0 处找到 expr 的剩余部分。

残差定义为幂级数展开中 1/(x-x0) 的系数，展开点为 x=x0。

参考文献

[1]

https://en.wikipedia.org/wiki/Residue_theorem

示例

>>> from sympy import Symbol, residue, sin
>>> x = Symbol("x")
>>> residue(1/x, x, 0)
1
>>> residue(1/x**2, x, 0)
0
>>> residue(2/sin(x), x, 0)
2

这个函数对于残数定理 [1] 是必不可少的。