组合¶

此模块实现了各种组合函数。

class sympy.functions.combinatorial.numbers.bell(n, k_sym=None, symbols=None)[源代码][源代码]¶

贝尔数 / 贝尔多项式

贝尔数满足 \(B_0 = 1\) 并且

\[B_n = \sum_{k=0}^{n-1} \binom{n-1}{k} B_k.\]

它们也可以由以下方式给出：

\[ \begin{align}\begin{aligned}B_n = \frac{1}{e} \sum_{k=0}^{\infty} \frac{k^n}{k!}.\\B_n = \frac{1}{e} \sum_{k=0}^{\infty} \frac{k^n}{k!}.\end{aligned}\end{align} \]

贝尔多项式由 \(B_0(x) = 1\) 给出，

\[ \begin{align}\begin{aligned}B_n(x) = x \sum_{k=1}^{n-1} \binom{n-1}{k-1} B_{k-1}(x).\\B_n(x) = x \sum_{k=1}^{n-1} \binom{n-1}{k-1} B_{k-1}(x).\end{aligned}\end{align} \]

第二类贝尔多项式（有时称为“部分”贝尔多项式或不完全贝尔多项式）定义为

\[B_{n,k}(x_1, x_2,\dotsc x_{n-k+1}) = \sum_{j_1+j_2+j_2+\dotsb=k \atop j_1+2j_2+3j_2+\dotsb=n} \frac{n!}{j_1!j_2!\dotsb j_{n-k+1}!} \left(\frac{x_1}{1!} \right)^{j_1} \left(\frac{x_2}{2!} \right)^{j_2} \dotsb \left(\frac{x_{n-k+1}}{(n-k+1)!} \right) ^{j_{n-k+1}}.\]

bell(n) 给出第 \(n^{th}\) 个贝尔数，\(B_n\)。
bell(n, x) 给出第 \(n^{th}\) 个贝尔多项式，\(B_n(x)\)。
bell(n, k, (x1, x2, ...)) 给出第二类贝尔多项式，\(B_{n,k}(x_1, x_2, \dotsc, x_{n-k+1})\)。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_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。
`eval`(n[, k_sym, symbols])
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

bernoulli, catalan, euler, fibonacci, harmonic, lucas, genocchi, partition, tribonacci

注释

不要与使用相同符号的伯努利数和伯努利多项式混淆。

参考文献

[1]

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

[2]

https://mathworld.wolfram.com/BellNumber.html

[3]

https://mathworld.wolfram.com/Bell多项式.html

示例

>>> from sympy import bell, Symbol, symbols

>>> [bell(n) for n in range(11)]
[1, 1, 2, 5, 15, 52, 203, 877, 4140, 21147, 115975]
>>> bell(30)
846749014511809332450147
>>> bell(4, Symbol('t'))
t**4 + 6*t**3 + 7*t**2 + t
>>> bell(6, 2, symbols('x:6')[1:])
6*x1*x5 + 15*x2*x4 + 10*x3**2

class sympy.functions.combinatorial.numbers.bernoulli(n, x=None)[源代码][源代码]¶

伯努利数 / 伯努利多项式 / 伯努利函数

伯努利数是一个由 \(B_0 = 1\) 定义的有理数序列，并且满足递归关系（\(n > 0\)）：

\[n+1 = \sum_{k=0}^n \binom{n+1}{k} B_k\]

它们也通常由其指数生成函数定义，即 \(\frac{x}{1 - e^{-x}}\)。对于奇数指数 > 1，伯努利数为零。

伯努利多项式满足类似的公式：

\[B_n(x) = \sum_{k=0}^n (-1)^k \binom{n}{k} B_k x^{n-k}\]

伯努利数和伯努利多项式之间的关系为 \(B_n(1) = B_n\)。

广义伯努利函数 \(\operatorname{B}(s, a)\) 对任意复数 \(s\) 和 \(a\) 定义，除了当 \(a\) 是非正整数且 \(s\) 不是非负整数的情况。对于固定的 \(a\)，它是 \(s\) 的整函数，与赫尔维茨 zeta 函数相关。

\[\begin{split}\operatorname{B}(s, a) = \begin{cases} -s \zeta(1-s, a) & s \ne 0 \\ 1 & s = 0 \end{cases}\end{split}\]

当 \(s\) 是一个非负整数时，此函数简化为伯努利多项式：\(\operatorname{B}(n, x) = B_n(x)\)。当 \(a\) 被省略时，它被假定为 1，从而得到（普通）伯努利函数，该函数插值伯努利数，并与黎曼 zeta 函数相关。

我们使用拉马努金公式计算伯努利数：

\[B_n = \frac{A(n) - S(n)}{\binom{n+3}{n}}\]

哪里：

\[\begin{split}A(n) = \begin{cases} \frac{n+3}{3} & n \equiv 0\ \text{或}\ 2 \pmod{6} \\ -\frac{n+3}{6} & n \equiv 4 \pmod{6} \end{cases}\end{split}\]

和：

\[S(n) = \sum_{k=1}^{[n/6]} \binom{n+3}{n-6k} B_{n-6k}\]

这个公式与定义中的和相似，但减少了 \(\frac{2}{3}\) 的项。对于伯努利多项式，我们使用阿佩尔序列。

对于 \(n\) 为非负整数，且 \(s\)、\(a\)、\(x\) 为任意复数，

bernoulli(n) 给出第 n 个伯努利数，\(B_n\)
bernoulli(s) 给出伯努利函数 \(\operatorname{B}(s)\)
bernoulli(n, x) 给出 \(x\) 中的第 n 个伯努利多项式，\(B_n(x)\)
bernoulli(s, a) 给出广义伯努利函数 \(\operatorname{B}(s, a)\)

在 1.12 版本发生变更: bernoulli(1) 给出 \(+\frac{1}{2}\) 而不是 \(-\frac{1}{2}\)。这个值的选择带来了几个理论上的优势 [5]，包括上述扩展到复数参数的实现。之前的行为，仅定义为非负整数 \(n\)，可以通过 (-1)**n*bernoulli(n) 获得。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_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。
`eval`(n[, x])
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

andre, bell, catalan, euler, fibonacci, harmonic, lucas, genocchi
partition, tribonacci, sympy.polys.appellseqs.bernoulli_poly

参考文献

[1]

https://zh.wikipedia.org/wiki/%E8%B4%9D%E5%A1%94%E4%B8%98%E6%95%B0

[2]

https://en.wikipedia.org/wiki/伯努利多项式

[3]

https://mathworld.wolfram.com/BernoulliNumber.html

[4]

https://mathworld.wolfram.com/Bernoulli多项式.html

[5]

Peter Luschny, “贝努利宣言”, https://luschny.de/math/zeta/The-Bernoulli-Manifesto.html

[6]

Peter Luschny, “An introduction to the Bernoulli function”, https://arxiv.org/abs/2009.06743

示例

>>> from sympy import bernoulli
>>> from sympy.abc import x
>>> [bernoulli(n) for n in range(11)]
[1, 1/2, 1/6, 0, -1/30, 0, 1/42, 0, -1/30, 0, 5/66]
>>> bernoulli(1000001)
0
>>> bernoulli(3, x)
x**3 - 3*x**2/2 + x/2

class sympy.functions.combinatorial.factorials.binomial(n, k)[源代码][源代码]¶

二项式系数的实现。它可以根据其期望的解释以两种方式定义：

\[\binom{n}{k} = \frac{n!}{k!(n-k)!}\ \text{或}\ \binom{n}{k} = \frac{(n)_k}{k!}\]

首先，在严格的组合意义上，它定义了从 \(n\) 个元素的集合中选择 \(k\) 个元素的方式数。在这种情况下，两个参数都是非负整数，并且使用基于素因数分解的高效算法计算二项式。

另一个定义是针对任意 \(n\) 的泛化，然而 \(k\) 也必须是非负的。这种情况在评估求和时非常有用。

为了方便起见，对于负整数 \(k\)，无论其他参数如何，此函数都将返回零。

当 \(n\) 是一个符号时，要展开二项式，可以使用 expand_func() 或 expand(func=True)。前者将保持多项式在因式分解的形式，而后者将展开多项式本身。详情请参见示例。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_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。
`eval`(n, k)
`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() 函数
`fdiff`([argindex])
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参考文献

[1]

https://www.johndcook.com/blog/binomial_coefficients/

[2]

https://zh.wikipedia.org/wiki/%E5%8D%A2%E5%8D%A1%E6%96%AF%E5%AE%9A%E7%90%86

[3]

模素数幂的二项式系数，Andrew Granville，可用链接: https://web.archive.org/web/20170202003812/http://www.dms.umontreal.ca/~andrew/PDF/BinCoeff.pdf

示例

>>> from sympy import Symbol, Rational, binomial, expand_func
>>> n = Symbol('n', integer=True, positive=True)

>>> binomial(15, 8)
6435

>>> binomial(n, -1)
0

帕斯卡三角形的行可以通过二项式函数生成：

>>> for N in range(8):
...     print([binomial(N, i) for i in range(N + 1)])
...
[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]
[1, 6, 15, 20, 15, 6, 1]
[1, 7, 21, 35, 35, 21, 7, 1]

正如给定的对角线，例如第4条对角线：

>>> N = -4
>>> [binomial(N, i) for i in range(1 - N)]
[1, -4, 10, -20, 35]

>>> binomial(Rational(5, 4), 3)
-5/128
>>> binomial(Rational(-5, 4), 3)
-195/128

>>> binomial(n, 3)
binomial(n, 3)

>>> binomial(n, 3).expand(func=True)
n**3/6 - n**2/2 + n/3

>>> expand_func(binomial(n, 3))
n*(n - 2)*(n - 1)/6

在许多情况下，我们也可以使用卢卡斯定理 [2] 快速计算模素数 p 的二项式系数，尽管我们需要包含 \(evaluate=False\) 来推迟评估：

>>> from sympy import Mod
>>> Mod(binomial(156675, 4433, evaluate=False), 10**5 + 3)
28625

利用Granville [3] 给出的Lucas定理的推广，我们可以将其扩展到任意n：

>>> Mod(binomial(10**18, 10**12, evaluate=False), (10**5 + 3)**2)
3744312326

class sympy.functions.combinatorial.numbers.catalan(n)[源代码][源代码]¶

卡塔兰数

第 \(n^{th}\) 个卡塔兰数由以下公式给出：

\[C_n = \frac{1}{n+1} \binom{2n}{n}\]

catalan(n) 给出第 \(n^{th}\) 个卡塔兰数，\(C_n\)

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_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。
`eval`(n)
`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() 函数
`fdiff`([argindex])
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

andre, bell, bernoulli, euler, fibonacci, harmonic, lucas, genocchi
partition, tribonacci, sympy.functions.combinatorial.factorials.binomial

参考文献

[1]

https://en.wikipedia.org/wiki/卡塔兰数

[2]

https://mathworld.wolfram.com/CatalanNumber.html

[3]

https://functions.wolfram.com/GammaBetaErf/CatalanNumber/

[4]

http://geometer.org/mathcircles/catalan.pdf

示例

>>> from sympy import (Symbol, binomial, gamma, hyper,
...     catalan, diff, combsimp, Rational, I)

>>> [catalan(i) for i in range(1,10)]
[1, 2, 5, 14, 42, 132, 429, 1430, 4862]

>>> n = Symbol("n", integer=True)

>>> catalan(n)
catalan(n)

卡塔兰数可以转化为其他几种涉及其他数学函数的相同表达式。

>>> catalan(n).rewrite(binomial)
binomial(2*n, n)/(n + 1)

>>> catalan(n).rewrite(gamma)
4**n*gamma(n + 1/2)/(sqrt(pi)*gamma(n + 2))

>>> catalan(n).rewrite(hyper)
hyper((-n, 1 - n), (2,), 1)

对于某些非整数值的 n，我们可以通过改写为伽马函数的形式来得到封闭形式的表达式：

>>> catalan(Rational(1, 2)).rewrite(gamma)
8/(3*pi)

我们可以将卡塔兰数 C(n) 解释为 n 中的连续实函数来区分：

>>> diff(catalan(n), n)
(polygamma(0, n + 1/2) - polygamma(0, n + 2) + log(4))*catalan(n)

作为一个更高级的例子，考虑以下连续数字之间的比率：

>>> combsimp((catalan(n + 1)/catalan(n)).rewrite(binomial))
2*(2*n + 1)/(n + 2)

卡塔兰数可以推广到复数：

>>> catalan(I).rewrite(gamma)
4**I*gamma(1/2 + I)/(sqrt(pi)*gamma(2 + I))

并以任意精度进行评估：

>>> catalan(I).evalf(20)
0.39764993382373624267 - 0.020884341620842555705*I

class sympy.functions.combinatorial.numbers.euler(n, x=None)[源代码][源代码]¶

欧拉数 / 欧拉多项式 / 欧拉函数

欧拉数由以下公式给出：

\[E_{2n} = I \sum_{k=1}^{2n+1} \sum_{j=0}^k \binom{k}{j} \frac{(-1)^j (k-2j)^{2n+1}}{2^k I^k k}\]

\[E_{2n+1} = 0\]

欧拉数和欧拉多项式是相关的。

\[E_n = 2^n E_n\left(\frac{1}{2}\right).\]

我们使用 Appell 序列计算符号欧拉多项式，但数值计算欧拉多项式时，使用 mpmath 库更为高效（且更为准确）。

欧拉多项式是广义欧拉函数的一种特殊情况，与Genocchi函数相关。

\[\operatorname{E}(s, a) = -\frac{\operatorname{G}(s+1, a)}{s+1}\]

当 \(s = -1\) 时，取 \(\psi\left(\frac{a+1}{2}\right) - \psi\left(\frac{a}{2}\right)\) 的极限。然后得到插值欧拉数的（普通）欧拉函数为 \(\operatorname{E}(s) = 2^s \operatorname{E}\left(s, \frac{1}{2}\right)\)。

euler(n) 给出第 n 个欧拉数 \(E_n\)。
euler(s) 给出欧拉函数 \(\operatorname{E}(s)\)。
euler(n, x) 给出第 n 个欧拉多项式 \(E_n(x)\)。
euler(s, a) 给出广义欧拉函数 \(\operatorname{E}(s, a)\)。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_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。
`eval`(n[, x])
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

andre, bell, bernoulli, catalan, fibonacci, harmonic, lucas, genocchi
partition, tribonacci, sympy.polys.appellseqs.euler_poly

参考文献

[1]

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

[2]

https://mathworld.wolfram.com/EulerNumber.html

[3]

https://zh.wikipedia.org/wiki/交错排列

[4]

https://mathworld.wolfram.com/AlternatingPermutation.html

示例

>>> from sympy import euler, Symbol, S
>>> [euler(n) for n in range(10)]
[1, 0, -1, 0, 5, 0, -61, 0, 1385, 0]
>>> [2**n*euler(n,1) for n in range(10)]
[1, 1, 0, -2, 0, 16, 0, -272, 0, 7936]
>>> n = Symbol("n")
>>> euler(n + 2*n)
euler(3*n)

>>> x = Symbol("x")
>>> euler(n, x)
euler(n, x)

>>> euler(0, x)
1
>>> euler(1, x)
x - 1/2
>>> euler(2, x)
x**2 - x
>>> euler(3, x)
x**3 - 3*x**2/2 + 1/4
>>> euler(4, x)
x**4 - 2*x**3 + x

>>> euler(12, S.Half)
2702765/4096
>>> euler(12)
2702765

class sympy.functions.combinatorial.factorials.factorial(n)[源代码][源代码]¶

非负整数的阶乘函数的实现。按照惯例（与伽玛函数和二项式系数一致），负整数的阶乘为复数无穷大。

阶乘在组合学中非常重要，它给出了 \(n\) 个对象可以排列的方式数。它还出现在微积分、概率论、数论等领域。

阶乘与伽玛函数有严格的关系。实际上，对于非负整数，\(n! = gamma(n+1)\)。这种重写在组合简化的情况下非常有用。

计算阶乘使用了两种算法。对于较小的参数，使用预计算的查找表。然而，对于较大的输入，使用 Prime-Swing 算法。这是已知最快的算法，通过特殊类数的质因数分解来计算 \(n!\)，这里称为 ‘Swing Numbers’。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_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。
`eval`(n)
`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() 函数
`fdiff`([argindex])
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

factorial2, RisingFactorial, FallingFactorial

示例

>>> from sympy import Symbol, factorial, S
>>> n = Symbol('n', integer=True)

>>> factorial(0)
1

>>> factorial(7)
5040

>>> factorial(-2)
zoo

>>> factorial(n)
factorial(n)

>>> factorial(2*n)
factorial(2*n)

>>> factorial(S(1)/2)
factorial(1/2)

class sympy.functions.combinatorial.factorials.subfactorial(arg)[源代码][源代码]¶

子阶乘计算 \(n\) 个项目的错排，并定义为非负整数：

\[\begin{split}!n = \begin{cases} 1 & n = 0 \\ 0 & n = 1 \\ (n-1)(!(n-1) + !(n-2)) & n > 1 \end{cases}\end{split}\]

它也可以写成 int(round(n!/exp(1))) ，但这个函数实现了带有缓存的递归定义。

一个有趣的分析表达式如下 [2]

\[!x = \Gamma(x + 1, -1)/e\]

这对于非负整数 \(x\) 是有效的。上述公式在非整数情况下不是很有用。\(\Gamma(x + 1, -1)\) 仅对整数参数 \(x\) 是单值的，在正实轴的其他地方，它有无数个分支，其中没有一个分支是实数。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_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。
`eval`(arg)
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

factorial, uppergamma
sympy.utilities.iterables.generate_derangements

参考文献

[1]

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

[2]

https://mathworld.wolfram.com/Subfactorial.html

示例

>>> from sympy import subfactorial
>>> from sympy.abc import n
>>> subfactorial(n + 1)
subfactorial(n + 1)
>>> subfactorial(5)
44

class sympy.functions.combinatorial.factorials.factorial2(arg)[源代码][源代码]¶

双阶乘 \(n!!\) ，不要与 \((n!)!\) 混淆。

双阶乘定义为非负整数和奇负整数：

\[\begin{split}n!! = \begin{cases} 1 & n = 0 \\ n(n-2)(n-4) \cdots 1 & n\ \text{正奇数} \\ n(n-2)(n-4) \cdots 2 & n\ \text{正偶数} \\ (n+2)!!/(n+2) & n\ \text{负奇数} \end{cases}\end{split}\]

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_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。
`eval`(arg)
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

factorial, RisingFactorial, FallingFactorial

参考文献

[1]

https://en.wikipedia.org/wiki/双阶乘

示例

>>> from sympy import factorial2, var
>>> n = var('n')
>>> n
n
>>> factorial2(n + 1)
factorial2(n + 1)
>>> factorial2(5)
15
>>> factorial2(-1)
1
>>> factorial2(-5)
1/3

class sympy.functions.combinatorial.factorials.FallingFactorial(x, k)[源代码][源代码]¶

下降阶乘（与上升阶乘相关）是一个在具体数学、超几何函数和级数展开中出现的双值函数。它由以下定义：

\[\texttt{ff(x, k)} = (x)_k = x \cdot (x-1) \cdots (x-k+1)\]

其中 \(x\) 可以是任意表达式，\(k\) 是一个整数。更多信息请查看 Graham 的《具体数学》，第66页或 [1]。

当 \(x\) 是一个单变量且次数 \(\ge 1\) 的 \(~.Poly\) 实例时，\((x)_k = x(y) \cdot x(y-1) \cdots x(y-k+1)\)，其中 \(y\) 是 \(x\) 的变量。如所述。

>>> from sympy import ff, Poly, Symbol
>>> from sympy.abc import x
>>> n = Symbol('n', integer=True)

>>> ff(x, 0)
1
>>> ff(5, 5)
120
>>> ff(x, 5) == x*(x - 1)*(x - 2)*(x - 3)*(x - 4)
True
>>> ff(Poly(x**2, x), 2)
Poly(x**4 - 2*x**3 + x**2, x, domain='ZZ')
>>> ff(n, n)
factorial(n)

除非知道参数之间的关系，否则重写是复杂的，但下降阶乘可以重写为伽玛函数、阶乘、二项式和上升阶乘的形式。

>>> from sympy import factorial, rf, gamma, binomial, Symbol
>>> n = Symbol('n', integer=True, positive=True)
>>> F = ff(n, n - 2)
>>> for i in (rf, ff, factorial, binomial, gamma):
...  F.rewrite(i)
...
RisingFactorial(3, n - 2)
FallingFactorial(n, n - 2)
factorial(n)/2
binomial(n, n - 2)*factorial(n - 2)
gamma(n + 1)/2

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_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。
`eval`(x, k)
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

factorial, factorial2, RisingFactorial

参考文献

[1]

https://mathworld.wolfram.com/FallingFactorial.html

[2]

Peter Paule, “最大阶乘因式分解与符号求和”, 符号计算杂志, 第20卷, 第235-268页, 1995年。

class sympy.functions.combinatorial.numbers.fibonacci(n, sym=None)[源代码][源代码]¶

斐波那契数 / 斐波那契多项式

斐波那契数列是由初始项 \(F_0 = 0\), \(F_1 = 1\) 以及二项递推关系 \(F_n = F_{n-1} + F_{n-2}\) 定义的整数序列。这个定义通过公式扩展到任意的实数和复数参数。

\[F_z = \frac{\phi^z - \cos(\pi z) \phi^{-z}}{\sqrt 5}\]

斐波那契多项式定义为 \(F_1(x) = 1\), \(F_2(x) = x\), 以及对于 \(n > 2\) 有 \(F_n(x) = x*F_{n-1}(x) + F_{n-2}(x)\)。对于所有正整数 \(n\), \(F_n(1) = F_n\)。

fibonacci(n) 给出第 \(n^{th}\) 个斐波那契数 \(F_n\)
fibonacci(n, x) 给出 \(x\) 中的第 \(n^{th}\) 个斐波那契多项式，\(F_n(x)\)

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_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。
`eval`(n[, sym])
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

bell, bernoulli, catalan, euler, harmonic, lucas, genocchi, partition, tribonacci

参考文献

[1]

https://en.wikipedia.org/wiki/斐波那契数

[2]

https://mathworld.wolfram.com/斐波那契数.html

示例

>>> from sympy import fibonacci, Symbol

>>> [fibonacci(x) for x in range(11)]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
>>> fibonacci(5, Symbol('t'))
t**4 + 3*t**2 + 1

class sympy.functions.combinatorial.numbers.tribonacci(n, sym=None)[源代码][源代码]¶

Tribonacci 数 / Tribonacci 多项式

Tribonacci 数是由初始项 \(T_0 = 0\), \(T_1 = 1\), \(T_2 = 1\) 和三项递推关系 \(T_n = T_{n-1} + T_{n-2} + T_{n-3}\) 定义的整数序列。

Tribonacci 多项式定义为 \(T_0(x) = 0\), \(T_1(x) = 1\), \(T_2(x) = x^2\), 以及对于 \(n > 2\) 有 \(T_n(x) = x^2 T_{n-1}(x) + x T_{n-2}(x) + T_{n-3}(x)\)。对于所有正整数 \(n\), \(T_n(1) = T_n\)。

tribonacci(n) 给出第 \(n^{th}\) 个 Tribonacci 数，\(T_n\)
tribonacci(n, x) 给出 \(x\) 中的 \(n^{th}\) Tribonacci 多项式，\(T_n(x)\)

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_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。
`eval`(n[, sym])
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

bell, bernoulli, catalan, euler, fibonacci, harmonic, lucas, genocchi, partition

参考文献

[1]

https://en.wikipedia.org/wiki/Generalizations_of_Fibonacci_numbers#Tribonacci_numbers

[2]

https://mathworld.wolfram.com/TribonacciNumber.html

[3]

https://oeis.org/A000073

示例

>>> from sympy import tribonacci, Symbol

>>> [tribonacci(x) for x in range(11)]
[0, 1, 1, 2, 4, 7, 13, 24, 44, 81, 149]
>>> tribonacci(5, Symbol('t'))
t**8 + 3*t**5 + 3*t**2

class sympy.functions.combinatorial.numbers.harmonic(n, m=None)[源代码][源代码]¶

调和数

第 n 个调和数由 \(\operatorname{H}_{n} = 1 + \frac{1}{2} + \frac{1}{3} + \ldots + \frac{1}{n}\) 给出。

更一般地：

\[\operatorname{H}_{n,m} = \sum_{k=1}^{n} \frac{1}{k^m}\]

当 \(n \rightarrow \infty\)，\(\operatorname{H}_{n,m} \rightarrow \zeta(m)\)，即黎曼zeta函数。

harmonic(n) 给出第 n 个调和数，\(\operatorname{H}_n\)
harmonic(n, m) 给出第 \(n\) 个 \(m\) 阶广义调和数 \(\operatorname{H}_{n,m}\)，其中 harmonic(n) == harmonic(n, 1)

此函数可以扩展到复杂的 \(n\) 和 \(m\)，其中 \(n\) 不是负整数或 \(m\) 是非正整数。

\[\begin{split}\operatorname{H}_{n,m} = \begin{cases} \zeta(m) - \zeta(m, n+1) & m \ne 1 \\ \psi(n+1) + \gamma & m = 1 \end{cases}\end{split}\]

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_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。
`eval`(n[, m])
`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() 函数
`fdiff`([argindex])
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

bell, bernoulli, catalan, euler, fibonacci, lucas, genocchi, partition, tribonacci

参考文献

[1]

https://zh.wikipedia.org/wiki/调和级数

[2]

https://functions.wolfram.com/GammaBetaErf/HarmonicNumber/

[3]

https://functions.wolfram.com/GammaBetaErf/HarmonicNumber2/

示例

>>> from sympy import harmonic, oo

>>> [harmonic(n) for n in range(6)]
[0, 1, 3/2, 11/6, 25/12, 137/60]
>>> [harmonic(n, 2) for n in range(6)]
[0, 1, 5/4, 49/36, 205/144, 5269/3600]
>>> harmonic(oo, 2)
pi**2/6

>>> from sympy import Symbol, Sum
>>> n = Symbol("n")

>>> harmonic(n).rewrite(Sum)
Sum(1/_k, (_k, 1, n))

我们可以对所有整数和正有理数参数求调和数：

>>> from sympy import S, expand_func, simplify
>>> harmonic(8)
761/280
>>> harmonic(11)
83711/27720

>>> H = harmonic(1/S(3))
>>> H
harmonic(1/3)
>>> He = expand_func(H)
>>> He
-log(6) - sqrt(3)*pi/6 + 2*Sum(log(sin(_k*pi/3))*cos(2*_k*pi/3), (_k, 1, 1))
                       + 3*Sum(1/(3*_k + 1), (_k, 0, 0))
>>> He.doit()
-log(6) - sqrt(3)*pi/6 - log(sqrt(3)/2) + 3
>>> H = harmonic(25/S(7))
>>> He = simplify(expand_func(H).doit())
>>> He
log(sin(2*pi/7)**(2*cos(16*pi/7))/(14*sin(pi/7)**(2*cos(pi/7))*cos(pi/14)**(2*sin(pi/14)))) + pi*tan(pi/14)/2 + 30247/9900
>>> He.n(40)
1.983697455232980674869851942390639915940
>>> harmonic(25/S(7)).n(40)
1.983697455232980674869851942390639915940

我们可以用多伽玛函数的形式重写调和数：

>>> from sympy import digamma, polygamma
>>> m = Symbol("m", integer=True, positive=True)

>>> harmonic(n).rewrite(digamma)
polygamma(0, n + 1) + EulerGamma

>>> harmonic(n).rewrite(polygamma)
polygamma(0, n + 1) + EulerGamma

>>> harmonic(n,3).rewrite(polygamma)
polygamma(2, n + 1)/2 + zeta(3)

>>> simplify(harmonic(n,m).rewrite(polygamma))
Piecewise((polygamma(0, n + 1) + EulerGamma, Eq(m, 1)),
(-(-1)**m*polygamma(m - 1, n + 1)/factorial(m - 1) + zeta(m), True))

参数中的整数偏移量可以被提取出来：

>>> from sympy import expand_func

>>> expand_func(harmonic(n+4))
harmonic(n) + 1/(n + 4) + 1/(n + 3) + 1/(n + 2) + 1/(n + 1)

>>> expand_func(harmonic(n-4))
harmonic(n) - 1/(n - 1) - 1/(n - 2) - 1/(n - 3) - 1/n

一些限制也可以计算：

>>> from sympy import limit, oo

>>> limit(harmonic(n), n, oo)
oo

>>> limit(harmonic(n, 2), n, oo)
pi**2/6

>>> limit(harmonic(n, 3), n, oo)
zeta(3)

对于 \(m > 1\)，在 \(n\) 趋于无穷大的极限情况下，\(H_{n,m}\) 趋向于 \(\zeta(m)\)：

>>> m = Symbol("m", positive=True)
>>> limit(harmonic(n, m+1), n, oo)
zeta(m + 1)

class sympy.functions.combinatorial.numbers.lucas(n)[源代码][源代码]¶

卢卡斯数

卢卡斯数满足一个类似于斐波那契数列的递推关系，其中每一项是前两项的和。它们通过选择初始值 \(L_0 = 2\) 和 \(L_1 = 1\) 生成。

lucas(n) 给出第 \(n^{th}\) 个卢卡斯数

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_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。
`eval`(n)
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

bell, bernoulli, catalan, euler, fibonacci, harmonic, genocchi, partition, tribonacci

参考文献

[1]

https://zh.wikipedia.org/wiki/%E5%8D%A2%E5%8D%A1%E6%95%B0

[2]

https://mathworld.wolfram.com/LucasNumber.html

示例

>>> from sympy import lucas

>>> [lucas(x) for x in range(11)]
[2, 1, 3, 4, 7, 11, 18, 29, 47, 76, 123]

class sympy.functions.combinatorial.numbers.genocchi(n, x=None)[源代码][源代码]¶

Genocchi 数 / Genocchi 多项式 / Genocchi 函数

Genocchi 数是一个整数序列 \(G_n\)，它们满足以下关系：

\[\frac{-2t}{1 + e^{-t}} = \sum_{n=0}^\infty \frac{G_n t^n}{n!}\]

它们与伯努利数相关。

\[G_n = 2 (1 - 2^n) B_n\]

并将伯努利数推广到 Genocchi 多项式和函数

\[\operatorname{G}(s, a) = 2 \left(\operatorname{B}(s, a) - 2^s \operatorname{B}\left(s, \frac{a+1}{2}\right)\right)\]

在 1.12 版本发生变更: genocchi(1) 给出 \(-1\) 而不是 \(1\)。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_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。
`eval`(n[, x])
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

bell, bernoulli, catalan, euler, fibonacci, harmonic, lucas, partition, tribonacci
sympy.polys.appellseqs.genocchi_poly

参考文献

[1]

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

[2]

https://mathworld.wolfram.com/GenocchiNumber.html

[3]

Peter Luschny, “An introduction to the Bernoulli function”, https://arxiv.org/abs/2009.06743

示例

>>> from sympy import genocchi, Symbol
>>> [genocchi(n) for n in range(9)]
[0, -1, -1, 0, 1, 0, -3, 0, 17]
>>> n = Symbol('n', integer=True, positive=True)
>>> genocchi(2*n + 1)
0
>>> x = Symbol('x')
>>> genocchi(4, x)
-4*x**3 + 6*x**2 - 1

class sympy.functions.combinatorial.numbers.andre(n)[源代码][源代码]¶

安德烈数 / 安德烈函数

Andre 数 \(\mathcal{A}_n\) 是 Luschny 对 \(n\) 个元素上 交替排列 数量的一半的命名，其中排列是交替的，如果相邻元素从左到右交替比较“大于”和“小于”。例如，\(2 < 3 > 1 < 4\) 是一个交替排列。

这个序列在OEIS中是A000111，它被赋予了*上升/下降数*和*欧拉之字形数*的名称。它满足一个类似于卡塔兰数的递推关系，其中 \(\mathcal{A}_0 = 1\) 并且

\[ \begin{align}\begin{aligned}2 \mathcal{A}_{n+1} = \sum_{k=0}^n \binom{n}{k} \mathcal{A}_k \mathcal{A}_{n-k}\\2 \mathcal{A}_{n+1} = \sum_{k=0}^n \binom{n}{k} \mathcal{A}_k \mathcal{A}_{n-k}\end{aligned}\end{align} \]

伯努利数和欧拉数分别是该序列的奇数和偶数索引元素的符号变换：

\[\operatorname{B}_{2k} = \frac{2k \mathcal{A}_{2k-1}}{(-4)^k - (-16)^k}\]

\[\operatorname{E}_{2k} = (-1)^k \mathcal{A}_{2k}\]

像伯努利数和欧拉数一样，安德烈数是由整个安德烈函数插值的：

\[\begin{split}\mathcal{A}(s) = (-i)^{s+1} \operatorname{Li}_{-s}(i) + i^{s+1} \operatorname{Li}_{-s}(-i) = \\ \frac{2 \Gamma(s+1)}{(2\pi)^{s+1}} (\zeta(s+1, 1/4) - \zeta(s+1, 3/4) \cos{\pi s})\end{split}\]

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_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。
`eval`(n)
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

bernoulli, catalan, euler, sympy.polys.appellseqs.andre_poly

参考文献

[1]

https://zh.wikipedia.org/wiki/交错排列

[2]

https://mathworld.wolfram.com/EulerZigzagNumber.html

[3]

Peter Luschny, “An introduction to the Bernoulli function”, https://arxiv.org/abs/2009.06743

示例

>>> from sympy import andre, euler, bernoulli
>>> [andre(n) for n in range(11)]
[1, 1, 1, 2, 5, 16, 61, 272, 1385, 7936, 50521]
>>> [(-1)**k * andre(2*k) for k in range(7)]
[1, -1, 5, -61, 1385, -50521, 2702765]
>>> [euler(2*k) for k in range(7)]
[1, -1, 5, -61, 1385, -50521, 2702765]
>>> [andre(2*k-1) * (2*k) / ((-4)**k - (-16)**k) for k in range(1, 8)]
[1/6, -1/30, 1/42, -1/30, 5/66, -691/2730, 7/6]
>>> [bernoulli(2*k) for k in range(1, 8)]
[1/6, -1/30, 1/42, -1/30, 5/66, -691/2730, 7/6]

class sympy.functions.combinatorial.numbers.partition(n)[源代码][源代码]¶

分区编号

分区数是一个整数序列 \(p_n\)，表示将 \(n\) 表示为自然数之和（顺序无关）的不同方式的数量。\(p_n\) 的生成函数由以下公式给出：

\[\[\sum_{n=0}^\infty p_n x^n = \prod_{k=1}^\infty (1 - x^k)^{-1}\]\]

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_free_symbols: 类似于 free_symbols，但仅在自由符号包含在表达式节点中时返回它们。
func: 表达式中的顶级函数。
is_antihermitian
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_composite
is_even
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_nonpositive
is_nonzero
is_number: 如果 self 没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。
is_odd
is_polar
is_positive
is_prime
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。
`eval`(n)
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

bell, bernoulli, catalan, euler, fibonacci, harmonic, lucas, genocchi, tribonacci

参考文献

[1]

https://en.wikipedia.org/wiki/Partition_(number_theory%29

[2]

https://zh.wikipedia.org/wiki/五角数定理

示例

>>> from sympy import partition, Symbol
>>> [partition(n) for n in range(9)]
[1, 1, 2, 3, 5, 7, 11, 15, 22]
>>> n = Symbol('n', integer=True, negative=True)
>>> partition(n)
0

class sympy.functions.combinatorial.numbers.divisor_sigma(n, k=1)[源代码][源代码]¶

计算正整数 n 的除数函数 \(\sigma_k(n)\)

divisor_sigma(n, k) 等于 sum([x**k for x in divisors(n)])

如果 n 的质因数分解为：

\[n = \prod_{i=1}^\omega p_i^{m_i},\]

然后

\[\[\sigma_k(n) = \prod_{i=1}^\omega (1+p_i^k+p_i^{2k}+\cdots + p_i^{m_ik}).\]\]

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_free_symbols: 类似于 free_symbols，但仅在自由符号包含在表达式节点中时返回它们。
func: 表达式中的顶级函数。
is_antihermitian
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_composite
is_even
is_number: 如果 self 没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。
is_odd
is_polar
is_prime

方法

`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。
`eval`(n[, k])
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

sympy.ntheory.factor_.divisor_count, totient, sympy.ntheory.factor_.divisors, sympy.ntheory.factor_.factorint

参考文献

[1]

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

示例

>>> from sympy.functions.combinatorial.numbers import divisor_sigma
>>> divisor_sigma(18, 0)
6
>>> divisor_sigma(39, 1)
56
>>> divisor_sigma(12, 2)
210
>>> divisor_sigma(37)
38

class sympy.functions.combinatorial.numbers.udivisor_sigma(n, k=1)[源代码][源代码]¶

计算正整数 n 的单位除数函数 \(\sigma_k^*(n)\)

udivisor_sigma(n, k) 等于 sum([x**k for x in udivisors(n)])

如果 n 的质因数分解为：

\[n = \prod_{i=1}^\omega p_i^{m_i},\]

然后

\[\sigma_k^*(n) = \prod_{i=1}^\omega (1+ p_i^{m_ik}).\]

参数:

k和中的除数幂

对于 k = 0, 1: udivisor_sigma(n, 0) 等于 udivisor_count(n) udivisor_sigma(n, 1) 等于 sum(udivisors(n))

k 的默认值是 1。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_free_symbols: 类似于 free_symbols，但仅在自由符号包含在表达式节点中时返回它们。
func: 表达式中的顶级函数。
is_antihermitian
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_composite
is_even
is_number: 如果 self 没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。
is_odd
is_polar
is_prime

方法

`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。
`eval`(n[, k])
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

sympy.ntheory.factor_.divisor_count, totient, sympy.ntheory.factor_.divisors
sympy.ntheory.factor_.udivisors, sympy.ntheory.factor_.udivisor_count, divisor_sigma
sympy.ntheory.factor_.factorint

参考文献

[1]

https://mathworld.wolfram.com/UnitaryDivisorFunction.html

示例

>>> from sympy.functions.combinatorial.numbers import udivisor_sigma
>>> udivisor_sigma(18, 0)
4
>>> udivisor_sigma(74, 1)
114
>>> udivisor_sigma(36, 3)
47450
>>> udivisor_sigma(111)
152

class sympy.functions.combinatorial.numbers.legendre_symbol(a, p)[源代码][源代码]¶

返回勒让德符号 \((a / p)\)。

对于整数 a 和奇素数 p，勒让德符号定义为

\[\begin{split}\genfrac(){}{}{a}{p} = \begin{cases} 0 & \text{如果 } p \text{ 整除 } a\\ 1 & \text{如果 } a \text{ 是模 } p \text{ 的二次剩余}\\ -1 & \text{如果 } a \text{ 是模 } p \text{ 的二次非剩余} \end{cases}\end{split}\]

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_free_symbols: 类似于 free_symbols，但仅在自由符号包含在表达式节点中时返回它们。
func: 表达式中的顶级函数。
is_antihermitian
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_composite
is_even
is_extended_negative
is_extended_nonnegative
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_negative
is_nonnegative
is_nonpositive
is_nonzero
is_number: 如果 self 没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。
is_odd
is_polar
is_positive
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。
`eval`(a, p)
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

sympy.ntheory.residue_ntheory.is_quad_residue, jacobi_symbol

示例

>>> from sympy.functions.combinatorial.numbers import legendre_symbol
>>> [legendre_symbol(i, 7) for i in range(7)]
[0, 1, 1, -1, 1, -1, -1]
>>> sorted(set([i**2 % 7 for i in range(7)]))
[0, 1, 2, 4]

class sympy.functions.combinatorial.numbers.jacobi_symbol(m, n)[源代码][源代码]¶

返回雅可比符号 \((m / n)\)。

对于任意整数 m 和任意正奇整数 n，雅可比符号定义为对应于 n 的质因数的勒让德符号的乘积：

\[\genfrac(){}{}{m}{n} = \genfrac(){}{}{m}{p^{1}}^{\alpha_1} \genfrac(){}{}{m}{p^{2}}^{\alpha_2} ... \genfrac(){}{}{m}{p^{k}}^{\alpha_k} \text{ 其中 } n = p_1^{\alpha_1} p_2^{\alpha_2} ... p_k^{\alpha_k}\]

类似于勒让德符号，如果雅可比符号 \(\genfrac(){}{}{m}{n} = -1\)，那么 m 是模 n 的二次非剩余。

但是，与勒让德符号不同，如果雅可比符号 \(\genfrac(){}{}{m}{n} = 1\)，那么 m 可能是也可能不是 n 的模二次剩余。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_free_symbols: 类似于 free_symbols，但仅在自由符号包含在表达式节点中时返回它们。
func: 表达式中的顶级函数。
is_antihermitian
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_composite
is_even
is_extended_negative
is_extended_nonnegative
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_negative
is_nonnegative
is_nonpositive
is_nonzero
is_number: 如果 self 没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。
is_odd
is_polar
is_positive
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。
`eval`(m, n)
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

sympy.ntheory.residue_ntheory.is_quad_residue, legendre_symbol

示例

>>> from sympy.functions.combinatorial.numbers import jacobi_symbol, legendre_symbol
>>> from sympy import S
>>> jacobi_symbol(45, 77)
-1
>>> jacobi_symbol(60, 121)
1

jacobi_symbol 和 legendre_symbol 之间的关系可以如下所示：

>>> L = legendre_symbol
>>> S(45).factors()
{3: 2, 5: 1}
>>> jacobi_symbol(7, 45) == L(7, 3)**2 * L(7, 5)**1
True

class sympy.functions.combinatorial.numbers.kronecker_symbol(a, n)[源代码][源代码]¶

返回 Kronecker 符号 \((a / n)\)。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_free_symbols: 类似于 free_symbols，但仅在自由符号包含在表达式节点中时返回它们。
func: 表达式中的顶级函数。
is_antihermitian
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_composite
is_even
is_extended_negative
is_extended_nonnegative
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_negative
is_nonnegative
is_nonpositive
is_nonzero
is_number: 如果 self 没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。
is_odd
is_polar
is_positive
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。
`eval`(a, n)
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

jacobi_symbol, legendre_symbol

参考文献

[1]

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

示例

>>> from sympy.functions.combinatorial.numbers import kronecker_symbol
>>> kronecker_symbol(45, 77)
-1
>>> kronecker_symbol(13, -120)
1

class sympy.functions.combinatorial.numbers.mobius(n)[源代码][源代码]¶

Mobius 函数将自然数映射到 {-1, 0, 1}

它定义如下：

\(1\) 如果 \(n = 1\)。
\(0\) 如果 \(n\) 有平方的质因数。
\((-1)^k\) 如果 \(n\) 是一个无平方因子的正整数，且有 \(k\) 个质因数。

它是数论和组合数学中的一个重要乘法函数。它在数学级数、代数数论中都有应用，并且在物理学中也有应用（费米子算符在Möbius函数模型中有非常具体的实现）。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_free_symbols: 类似于 free_symbols，但仅在自由符号包含在表达式节点中时返回它们。
func: 表达式中的顶级函数。
is_antihermitian
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_composite
is_even
is_extended_negative
is_extended_nonnegative
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_negative
is_nonnegative
is_nonpositive
is_nonzero
is_number: 如果 self 没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。
is_odd
is_polar
is_positive
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。
`eval`(n)
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参考文献

[1]

https://en.wikipedia.org/wiki/莫比乌斯函数

[2]

Thomas Koshy 的《Elementary Number Theory with Applications》

[3]

https://oeis.org/A008683

示例

>>> from sympy.functions.combinatorial.numbers import mobius
>>> mobius(13*7)
1
>>> mobius(1)
1
>>> mobius(13*7*5)
-1
>>> mobius(13**2)
0

即使对于一个符号，如果它明显包含一个平方的素数因子，它将为零。

>>> from sympy import Symbol
>>> n = Symbol("n", integer=True, positive=True)
>>> mobius(4*n)
0
>>> mobius(n**2)
0

class sympy.functions.combinatorial.numbers.primenu(n)[源代码][源代码]¶

计算正整数 n 的不同质因数的数量。

如果 n 的质因数分解为：

\[n = \prod_{i=1}^k p_i^{m_i},\]

那么 primenu(n) 或 \(\nu(n)\) 是：

\[\nu(n) = k.\]

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_free_symbols: 类似于 free_symbols，但仅在自由符号包含在表达式节点中时返回它们。
func: 表达式中的顶级函数。
is_antihermitian
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_composite
is_even
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_nonpositive
is_nonzero
is_number: 如果 self 没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。
is_odd
is_polar
is_positive
is_prime
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。
`eval`(n)
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

sympy.ntheory.factor_.factorint

参考文献

[1]

https://mathworld.wolfram.com/PrimeFactor.html

[2]

https://oeis.org/A001221

示例

>>> from sympy.functions.combinatorial.numbers import primenu
>>> primenu(1)
0
>>> primenu(30)
3

class sympy.functions.combinatorial.numbers.primeomega(n)[源代码][源代码]¶

计算正整数 n 的质因数个数（包括重复计数）。

如果 n 的质因数分解为：

\[n = \prod_{i=1}^k p_i^{m_i},\]

那么 primeomega(n) 或 \(\Omega(n)\) 是：

\[\Omega(n) = \sum_{i=1}^k m_i.\]

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_free_symbols: 类似于 free_symbols，但仅在自由符号包含在表达式节点中时返回它们。
func: 表达式中的顶级函数。
is_antihermitian
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_composite
is_even
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_nonpositive
is_nonzero
is_number: 如果 self 没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。
is_odd
is_polar
is_positive
is_prime
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。
`eval`(n)
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

sympy.ntheory.factor_.factorint

参考文献

[1]

https://mathworld.wolfram.com/PrimeFactor.html

[2]

https://oeis.org/A001222

示例

>>> from sympy.functions.combinatorial.numbers import primeomega
>>> primeomega(1)
0
>>> primeomega(20)
3

class sympy.functions.combinatorial.numbers.totient(n)[源代码][源代码]¶

计算欧拉函数 phi(n)

totient(n) 或 \(\phi(n)\) 是小于等于 n 且与 n 互质的正整数个数。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_free_symbols: 类似于 free_symbols，但仅在自由符号包含在表达式节点中时返回它们。
func: 表达式中的顶级函数。
is_antihermitian
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_composite
is_even
is_number: 如果 self 没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。
is_odd
is_polar
is_prime

方法

`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。
`eval`(n)
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

sympy.ntheory.factor_.divisor_count

参考文献

[1]

https://en.wikipedia.org/wiki/Euler%27s_totient_function

[2]

https://mathworld.wolfram.com/TotientFunction.html

[3]

https://oeis.org/A000010

示例

>>> from sympy.functions.combinatorial.numbers import totient
>>> totient(1)
1
>>> totient(25)
20
>>> totient(45) == totient(5)*totient(9)
True

class sympy.functions.combinatorial.numbers.reduced_totient(n)[源代码][源代码]¶

计算 Carmichael 约简完全数函数 lambda(n)

reduced_totient(n) 或 \(\lambda(n)\) 是使得 \(k^m \equiv 1 \mod n\) 对所有与 n 互质的 k 成立的最小 m > 0。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_free_symbols: 类似于 free_symbols，但仅在自由符号包含在表达式节点中时返回它们。
func: 表达式中的顶级函数。
is_antihermitian
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_composite
is_even
is_number: 如果 self 没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。
is_odd
is_polar
is_prime

方法

`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。
`eval`(n)
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

totient

参考文献

[1]

https://zh.wikipedia.org/wiki/%E5%8D%A1%E7%B1%B3%E5%85%8B%E5%B0%94%E5%87%BD%E6%95%B0

[2]

https://mathworld.wolfram.com/Carmichael函数.html

[3]

https://oeis.org/A002322

示例

>>> from sympy.functions.combinatorial.numbers import reduced_totient
>>> reduced_totient(1)
1
>>> reduced_totient(8)
2
>>> reduced_totient(30)
4

class sympy.functions.combinatorial.numbers.primepi(n)[源代码][源代码]¶

表示素数计数函数 pi(n) = 小于或等于 n 的素数的数量。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_free_symbols: 类似于 free_symbols，但仅在自由符号包含在表达式节点中时返回它们。
func: 表达式中的顶级函数。
is_antihermitian
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_composite
is_even
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_nonpositive
is_nonzero
is_number: 如果 self 没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。
is_odd
is_polar
is_positive
is_prime
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。
`eval`(n)
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

sympy.ntheory.primetest.isprime: 测试 n 是否为质数
sympy.ntheory.generate.primerange: 生成给定范围内的所有质数
sympy.ntheory.generate.prime: 返回第 n 个质数

参考文献

[1]

https://oeis.org/A000720

示例

>>> from sympy.functions.combinatorial.numbers import primepi
>>> from sympy import prime, prevprime, isprime
>>> primepi(25)
9

所以有9个小于或等于25的质数。25是质数吗？

>>> isprime(25)
False

它不是。因此，小于25的第一个质数必须是第9个质数：

>>> prevprime(25) == prime(9)
True

class sympy.functions.combinatorial.factorials.MultiFactorial(*args)[源代码][源代码]¶

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_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。
`eval`(*args)	返回应用于参数 args 的 cls 的规范形式。
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

class sympy.functions.combinatorial.factorials.RisingFactorial(x, k)[源代码][源代码]¶

上升阶乘（也称为Pochhammer符号 [1]）是具体数学、超几何函数和级数展开中出现的一个双值函数。它定义为：

\[\texttt{rf(y, k)} = (x)^k = x \cdot (x+1) \cdots (x+k-1)\]

其中 \(x\) 可以是任意表达式，而 \(k\) 是一个整数。更多信息请查阅 Graham 所著的《具体数学》第 66 页，或访问 https://mathworld.wolfram.com/RisingFactorial.html 页面。

当 \(x\) 是一个单变量且次数 \(\ge 1\) 的 \(~.Poly\) 实例时，\((x)^k = x(y) \cdot x(y+1) \cdots x(y+k-1)\)，其中 \(y\) 是 \(x\) 的变量。如 [2] 中所述。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_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。
`eval`(x, k)
`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() 函数
`fdiff`([argindex])	返回函数的导数。
`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。
`is_singular`(a)	测试参数是否为本质奇点或分支点，或者函数是否为非全纯函数。
`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`(**_)

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

参见

factorial, factorial2, FallingFactorial

参考文献

[1]

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

[2]

Peter Paule, “最大阶乘因式分解与符号求和”, 符号计算杂志, 第20卷, 第235-268页, 1995年。

示例

>>> from sympy import rf, Poly
>>> from sympy.abc import x
>>> rf(x, 0)
1
>>> rf(1, 5)
120
>>> rf(x, 5) == x*(1 + x)*(2 + x)*(3 + x)*(4 + x)
True
>>> rf(Poly(x**3, x), 2)
Poly(x**6 + 3*x**5 + 3*x**4 + x**3, x, domain='ZZ')

除非知道参数之间的关系，否则重写是复杂的，但上升阶乘可以用伽玛函数、阶乘、二项式和下降阶乘来重写。

>>> from sympy import Symbol, factorial, ff, binomial, gamma
>>> n = Symbol('n', integer=True, positive=True)
>>> R = rf(n, n + 2)
>>> for i in (rf, ff, factorial, binomial, gamma):
...  R.rewrite(i)
...
RisingFactorial(n, n + 2)
FallingFactorial(2*n + 1, n + 2)
factorial(2*n + 1)/factorial(n - 1)
binomial(2*n + 1, n + 2)*factorial(n + 2)
gamma(2*n + 2)/gamma(n)

sympy.functions.combinatorial.numbers.stirling(n, k, d=None, kind=2, signed=False)[源代码][源代码]¶

返回第一类或第二类（默认）斯特林数 \(S(n, k)\)。

所有第二类斯特林数从 \(k = 1\) 到 \(n\) 的总和是 bell(n)。这些数的递推关系是：

\[{0 \brace 0} = 1; {n \brace 0} = {0 \brace k} = 0;\]

\[{{n+1} \brace k} = j {n \brace k} + {n \brace {k-1}}\]

其中 \(j\) 是：: \(n\) 表示第一类斯特林数，\(-n\) 表示带符号的第一类斯特林数，\(k\) 表示第二类斯特林数。

第一类斯特林数计算``n``个不同项的排列中具有``k``个循环的排列数；第二类斯特林数计算``n``个不同项可以被划分为``k``个部分的方式数。如果给定``d``，则返回“简化第二类斯特林数”：\(S^{d}(n, k) = S(n - d + 1, k - d + 1)\)，其中\(n \ge k \ge d\)。（这计算了将``n``个连续整数划分为``k``个组的方式数，且每组中任意两数之差不小于``d``。参见下面的示例。）

要获取第一类带符号的斯特林数，请使用关键字 signed=True。使用此关键字会自动将 kind 设置为 1。

参见

sympy.utilities.iterables.multiset_partitions

参考文献

[1]

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

[2]

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

示例

>>> from sympy.functions.combinatorial.numbers import stirling, bell
>>> from sympy.combinatorics import Permutation
>>> from sympy.utilities.iterables import multiset_partitions, permutations

第一种类型（默认无符号）：

>>> [stirling(6, i, kind=1) for i in range(7)]
[0, 120, 274, 225, 85, 15, 1]
>>> perms = list(permutations(range(4)))
>>> [sum(Permutation(p).cycles == i for p in perms) for i in range(5)]
[0, 6, 11, 6, 1]
>>> [stirling(4, i, kind=1) for i in range(5)]
[0, 6, 11, 6, 1]

第一种（带符号）：

>>> [stirling(4, i, signed=True) for i in range(5)]
[0, -6, 11, -6, 1]

第二种：

>>> [stirling(10, i) for i in range(12)]
[0, 1, 511, 9330, 34105, 42525, 22827, 5880, 750, 45, 1, 0]
>>> sum(_) == bell(10)
True
>>> len(list(multiset_partitions(range(4), 2))) == stirling(4, 2)
True

减少的第二类：

>>> from sympy import subsets, oo
>>> def delta(p):
...    if len(p) == 1:
...        return oo
...    return min(abs(i[0] - i[1]) for i in subsets(p, 2))
>>> parts = multiset_partitions(range(5), 3)
>>> d = 2
>>> sum(1 for p in parts if all(delta(i) >= d for i in p))
7
>>> stirling(5, 3, 2)
7

枚举¶

有三种函数可用。每个函数都尝试高效地计算给定集合或多重集的给定组合量，该集合或多重集可以作为整数、序列或多重集（以元素为键、以重复次数为值的字典）输入。k 参数表示要选择的元素数量（或要进行的分区数量）。当 k 为 None 时，返回所有 k``（从 0 到 ``n 所表示的项数）的枚举总和。对于组合和排列，识别 replacement 参数；这表示任何项可能以与原始集合中项数相同的重复次数出现。

>>> from sympy.functions.combinatorial.numbers import nC, nP, nT
>>> items = 'baby'

sympy.functions.combinatorial.numbers.nC(n, k=None, replacement=False)[源代码][源代码]¶

返回从 n 个项目中每次取 k 个的组合数。

n 的可能值：

整数 - 长度为 n 的集合

sequence - 在内部转换为多重集

multiset - {元素: 多重性}

如果 k 是 None，那么将返回长度从 0 到 n 中所有项的组合总数。

如果 replacement 为 True，则给定项可以在 k 项中出现多次。（例如，对于 ‘ab’ 集合，2 的组合将包括 ‘aa’、’ab’ 和 ‘bb’。）当 replacement 为 True 时，n 中元素的多重性被忽略，但元素的总数被考虑，因为没有任何元素出现的次数可以超过 n 中元素的数量。

参见

sympy.utilities.iterables.multiset_combinations

参考文献

[1]

https://en.wikipedia.org/wiki/组合

[2]

https://tinyurl.com/cep849r

示例

>>> from sympy.functions.combinatorial.numbers import nC
>>> from sympy.utilities.iterables import multiset_combinations
>>> nC(3, 2)
3
>>> nC('abc', 2)
3
>>> nC('aab', 2)
2

当 replacement 为 True 时，每个项目可以具有等于 n 所表示长度的多重性：

>>> nC('aabc', replacement=True)
35
>>> [len(list(multiset_combinations('aaaabbbbcccc', i))) for i in range(5)]
[1, 3, 6, 10, 15]
>>> sum(_)
35

如果有 k 个项目，其重复次数分别为 m_1, m_2, ..., m_k，那么所有长度从 0 到 k 的组合总数是乘积，(m_1 + 1)*(m_2 + 1)*...*(m_k + 1)。当每个项目的重复次数为 1 时（即，k 个唯一项目），则有 2**k 种组合。例如，如果有 4 个唯一项目，组合总数为 16：

>>> sum(nC(4, i) for i in range(5))
16

sympy.functions.combinatorial.numbers.nP(n, k=None, replacement=False)[源代码][源代码]¶

返回从 n 个项目中一次取 k 个的排列数。

n 的可能值：

整数 - 长度为 n 的集合

sequence - 在内部转换为多重集

multiset - {元素: 多重性}

如果 k 是 None，那么将返回长度从 0 到 n 所表示的项数的所有排列的总和。

如果 replacement 为 True，则给定的项可以在 k 项中出现多次。（例如，对于 ‘ab’ 的 2 个排列，将包括 ‘aa’, ‘ab’, ‘ba’ 和 ‘bb’。）当 replacement 为 True 时，n 中元素的多重性被忽略，但元素的总数被考虑，因为没有任何元素可以出现的次数超过 n 中元素的数量。

参见

sympy.utilities.iterables.multiset_permutations

参考文献

[1]

https://zh.wikipedia.org/wiki/排列

示例

>>> from sympy.functions.combinatorial.numbers import nP
>>> from sympy.utilities.iterables import multiset_permutations, multiset
>>> nP(3, 2)
6
>>> nP('abc', 2) == nP(multiset('abc'), 2) == 6
True
>>> nP('aab', 2)
3
>>> nP([1, 2, 2], 2)
3
>>> [nP(3, i) for i in range(4)]
[1, 3, 6, 6]
>>> nP(3) == sum(_)
True

当 replacement 为 True 时，每个项目可以具有等于 n 所表示长度的多重性：

>>> nP('aabc', replacement=True)
121
>>> [len(list(multiset_permutations('aaaabbbbcccc', i))) for i in range(5)]
[1, 3, 9, 27, 81]
>>> sum(_)
121

sympy.functions.combinatorial.numbers.nT(n, k=None)[源代码][源代码]¶

返回 n 个项目的 k 大小分区的数量。

n 的可能值：

整数 - n 个相同项

sequence - 在内部转换为多重集

multiset - {元素: 多重性}

注意：nT 的约定与 nC 和 nP 不同，这里的整数表示 n 个相同的项，而不是长度为 n 的集合；这与 partitions 函数一致，该函数将其整数 n 输入视为 n 个 1 的列表。可以使用 range(n) 表示 n 个不同的项。

如果 k 是 None，那么将返回表示在 n 中的元素的分区总方式数。

参见

sympy.utilities.iterables.partitions
sympy.utilities.iterables.multiset_partitions
sympy.functions.combinatorial.numbers.partition

参考文献

[1]

https://web.archive.org/web/20210507012732/https://teaching.csse.uwa.edu.au/units/CITS7209/partition.pdf

示例

>>> from sympy.functions.combinatorial.numbers import nT

给定多重集的分区：

>>> [nT('aabbc', i) for i in range(1, 7)]
[1, 8, 11, 5, 1, 0]
>>> nT('aabbc') == sum(_)
True

>>> [nT("mississippi", i) for i in range(1, 12)]
[1, 74, 609, 1521, 1768, 1224, 579, 197, 50, 9, 1]

所有项目相同时的分区：

>>> [nT(5, i) for i in range(1, 6)]
[1, 2, 2, 1, 1]
>>> nT('1'*5) == sum(_)
True

当所有项目都不同时：

>>> [nT(range(5), i) for i in range(1, 6)]
[1, 15, 25, 10, 1]
>>> nT(range(5)) == sum(_)
True

整数的分区表示为正整数的和：

>>> from sympy import partition
>>> partition(4)
5
>>> nT(4, 1) + nT(4, 2) + nT(4, 3) + nT(4, 4)
5
>>> nT('1'*4)
5